1. Spring
1.1 简介
Spring:春天
2002,首次推出了Spring的出行:interface21框架!
Spring框架即以interface21框架为基础,经过重新设计,并不断丰富其内涵,雨2004
年3月24日,发布了1.0正式版
Rod Johnson,SpringFarmework创始人
spring理念:使现有的技术更加容易使用,本身是一个大杂烩,整合了现有的技术框架!
SSH:Struct2 + Spring + Hibernate (Spring没出来以前)
SSM:SpringMvc + Spring + Mybatis
官网: https://spring.io/projects/spring-framework#overview
GitHub:https://github.com/spring-projects/spring-framework
1 2 3 4 5 6
| <!-- https: <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>6.1.8</version> </dependency>
|
1.2 优点
- Spring 是一个开源的免费框架(容器)
- Spring 是一公分轻量级的、非入侵式的框架
- 控制反转(IOC)、面向切面编程(AOP)
- 支持事务的处理,对框架整合的支持
==总结一句话:Spring就是一个轻量级的控制反转 (IOC)和面向切面编程 (AOP)的框架!==
1.3 组成

1.4 拓展
现代化的 Java开发 ,说白了就是基于Spring开发

- Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
- 约定大于配置!
- Spring Cloud
- Spring Cloud 是基于SpringBoot 实现的
现在大多数都在使用SpringBoot开发,学习SpringBoot的前提,需要完全掌握Spring及SpringMvc!承上启下的作用!
弊端:发展了太久之后,违背了原来的理念!配置十分繁琐,人称 “配置地狱!”
2. IOC理论推导
UserDao接口
UserDaoImpl业务实现
UserService接口
UserServiceImpl业务实现
UserDao接口
1 2 3 4 5
| package org.raehp.dao;
public interface UserDao { void getUser(); }
|
UserDaoImpl
1 2 3 4 5 6 7 8
| package org.raehp.dao;
public class UserDaoImpl implements UserDao{ @Override public void getUser() { System.out.println("UserDaoImpl获取用户数据"); } }
|
UserService
1 2 3 4 5
| package org.raehp.service;
public interface UserService { void getUser(); }
|
UserServiceImpl
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
| package org.raehp.service;
import org.raehp.dao.UserDao; import org.raehp.dao.UserDaoImpl; import org.raehp.dao.UserMySQLImpl;
public class UserServiceImpl implements UserService{ private UserDao userDao = new UserDao(); private UserDao userDao = new UserMySqlDao(); private UserDao userDao = new UserOracleDao();
@Override public void getUser() { userDao.getUser(); } }
|
Test类
1 2 3 4 5 6 7
| public class AppTest { public static void main(String[] args) { UserService userService = new UserServiceImpl(); userService.getUser(); } }
|

在我们之前的业务中,用户的需求可能会影响我们原来的代码。我们需要根据用户的需求去修改源代码!如果程序代码量十分大,修改一次的成本代价十分昂贵
我们使用一个set接口实现,已经发生了革命性的变化
UserServiceImpl
1 2 3 4 5
| private UserDao userDao;
public void setUserDao(UserDao userDao) { this.userDao = userDao }
|
Test类
1 2 3 4 5 6 7 8
| public class AppTest { public static void main(String[] args) { UserService userService = new UserServiceImpl();
((UserServiceImpl) userService).setUserDao(new UserMySQLImpl()); userService.getUser(); } }
|

- 之前是主动创建对象!控制权在程序员手上
- 使用了set注入后,程序不再具有主动性,而是变成了被动的接受对象!
这种思想,本质上解决了问题,我们程序员不用再去管理对象的创建了。系统的耦合性大大降低~可以更加专注的在业务的实现上!这是IOC的原型!
IOC本质
控制反转IoC(Inversion of Control)是一种设计思想,DI(依赖注入)是实现IoC的一种方法,也有人认为DI知识IoC的另一种说法,没有Ioc的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。
采用XML的方式配置Bean的时候,Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。
控制反转是一种通过描述 (XML或注解) 并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是loC容器,其实现方法是依赖注入(DependencyIniection,Dl)
3. Hello Srping
创建Hello.class
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
| package org.raehp.pojo;
public class Hello { public String name;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
@Override public String toString() { return "Hello{" + "name='" + name + '\'' + '}'; } }
|
在resources 下创建 beans.xml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
| <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="hello" class="org.raehp.pojo.Hello"> <property name="name" value="zhangsan" /> </bean>
</beans>
|
Test类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| package org.raehp;
import org.raehp.pojo.Hello; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AppTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Hello hello = (Hello) context.getBean("hello"); System.out.println(hello.toString()); } }
|
思考问题?
- Hello 对象是谁创建的?
- Hello 对象的属性是怎么设置的?
这个过程就叫控制反转:
控制:谁来控制对象的创建,传统应用程序的对象室友程序本身控制创建的,使用Spring后,对象是由Spring来创建的
反转:程序本身不创建对象,而变成被动的接收对象
依赖注入:就是利用set方法进行注入的
IOC是一种编程思想:由主动的编程变成被动的接收
可以通过new ClassPathXmlApplicationContext 去浏览一下底层源码
4. IOC容器创建的方式
使用无参构造创建对象,默认!
假设我们要使用有参构造创建对象
下标赋值
1 2 3 4
| <bean id="user" class="org.raehp.pojo.User"> <constructor-arg index="0" value="昊郝好" /> </bean>
|
参数类型赋值
1 2 3 4
| <bean id="user" class="org.raehp.pojo.User">--> <constructor-arg type="java.lang.String" value="郝昊好"></constructor-arg> </bean>
|
参数名赋值
1 2 3 4
| <bean id="user" class="org.raehp.pojo.User"> <constructor-arg name="name" value="好昊郝昊郝"></constructor-arg> </bean>
|
总结:在配置文件加载的时候,容器中管理的对象就已经初始化了!
5. Spring 配置
5.1 别名
1 2
| <alias name="user" alias="userNew" />
|
5.2 Bean的配置
1 2 3 4 5 6 7 8
|
<bean id="userT" class="com.raehp.pojo.User" name="user2 u2,u3;u4">// 可以用空格,;分割 <property name="name" value="西部开源" /> </bean>
|
5.3 import
import,一般用于团队开发使用,他可以将多个配置文件,导入合并为一个
假设,现在项目中有多个人开发,这三个人复制不同的类开发,不同的类型需要注册在不同的bean中,我们可以利用import将所有人的beans.xml合并为一个总的
1 2 3
| <import resource="base.xml"> <import resource="base2.xml"> <import resource="base3.xml">
|
使用的时候,直接使用总的配置就可以了
6. 依赖注入
6.1 构造器注入
前面已经说过了
6.2 Set方式注入
- 依赖注入
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象中所有的属性,由容器来注入
【环境搭建】
复杂类型
1 2 3 4 5 6 7 8 9 10 11
| public class Address { private String address;
public String getAddress() { return address; }
public void setAddress(String address) { this.address = address; } }
|
真实测试对象
1 2 3 4 5 6 7 8 9 10 11
| public class Student {
private String name; private Address address; private String[] books; private List<String> hobbys; private Map<String, String> card; private Set<String> games; private String wife; private Properties info; }
|
application.xml
1 2 3 4
| <bean id="student" class="org.raehp.pojo.Student"> <property name="name" value="张某"></property> </bean>
|
Test类
1 2 3 4 5 6 7
| public class AppTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("application.xml"); Student student = (Student) context.getBean("student"); System.out.println(student.getName()); } }
|
完善注入信息
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
| <bean id="address" class="org.raehp.pojo.Address"> <property name="address" value="河北"></property> </bean>
<bean id="student" class="org.raehp.pojo.Student"> <property name="name" value="张某"></property>
<property name="address" ref="address"></property>
<property name="books"> <array> <value>石昊</value> <value>石毅</value> <value>石冠王</value> <value>石骸仙帝</value> </array> </property>
<property name="hobbys"> <list> <value>哈哈哈</value> <value>呸呸呸</value> <value>哦哦哦</value> <value>呃呃呃</value> </list> </property>
<property name="card"> <map> <entry key="姓名" value="石昊"></entry> <entry key="宝术" value="鲲鹏宝术,柳神法,朱雀宝术"></entry> <entry key="能力" value="天生至尊骨"></entry> <entry key="实力" value="祭道之上"></entry> </map> </property>
<property name="games"> <set> <value>请请请</value> <value>呜呜呜</value> <value>鹅鹅鹅</value> <value>日日日</value> </set> </property>
<property name="wife"> <null/> </property>
<property name="info"> <props> <prop key="stuId">202202093</prop> <prop key="name">郝亚涵</prop> <prop key="gender">女</prop> </props> </property> </bean>
|
6.3 拓展方式注入
我们可以使用p命令空间和c命令空间进行注入
1 2 3 4 5 6 7 8 9 10 11 12
| <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="user" class="org.raehp.pojo.User" p:age="18" p:name="张三"></bean>
<bean id="user2" class="org.raehp.pojo.User" c:name="李四" c:age="20"></bean> </beans>
|
6.4 Bean的作用域
| 作用域 |
描述 |
| singleton |
在spring IoC容器仅存在一个Bean实例,Bean以单例方式存在,bean作用域范围的默认值。 |
| prototype |
每次从容器中调用Bean时,都返回一个新的实例,即每次调用getBean()时,相当于执行newXxxBean()。 |
| request |
每次HTTP请求都会创建一个新的Bean,该作用域仅适用于web的Spring WebApplicationContext环境。 |
| session |
session 同一个HTTP Session共享一个Bean,不同Session使用不同的Bean。该作用域仅于web的Spring WebApplicationContext环境。 |
| application |
限定一个Bean的作用域为ServletContext的生命周期。该作用域仅适用于web的Spring WebApplicationContext环境。 |
单例模式(Spring默认机制)
1
| <bean id="user2" class="com.raehp.pojo.User" c:name="xxx" scope="singleton" />
|
原型模式:每次从容器中get的时候,都会产生一个新对象
1
| <bean id="user2" class="com.raehp.pojo.User" c:name="xxx" scope="prototype" />
|
其余的request、session、application、这些只能在web开发中使用!
7. Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式
- Spring会在上下文中自动寻找,并自动给给bean装配属性
在Spring中有三种装配的方式
- 在xml中显示的配置
- 在java中显示配置
- 饮食的自动装配bean【⭐⭐⭐⭐⭐】
7.1 测试
环境搭建:一个人有两个动物
7.2 ByName自动装配
1 2 3 4 5 6 7 8 9
|
<bean id="dog" class="org.raehp.Dog" /> <bean id="cat" class="org.raehp.Cat" />
<bean id="people" class="org.raehp.People" autowire="byName"> <property name="name" value="郝部长"></property> </bean>
|
7.3 ByType
1 2 3 4 5 6 7 8 9
|
<bean class="org.raehp.Dog" /> <bean class="org.raehp.Cat" />
<bean id="people" class="org.raehp.People" autowire="byType"> <property name="name" value="郝部长"></property> </bean>
|
小结:
- byName的时候,要保证所有bean的id唯一,并且这个bean需要和自动注入的属性的set方法的值一致!
- byType的时候,要保证所有bean的class唯一,并且这个bean需要和自动注入的属性的类型一致!
7.4 注解实现自动装配
jdk1.5 支持的注解,Spring2.5就支持注解了
要使用注解须知:
- 导入约束:context约束
- ==配置注解的支持:context:annotion-config/==
1 2 3 4 5 6 7 8 9 10 11
| <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config /> </beans>
|
@Autowired
直接在属性上使用即可!也可以在set方式上使用
使用Autowired 我们可以不用编写set方法了,前提是你这个自动装配的属性在 IOC(Spring)容器中存在,且符合名字byName!
科普:
1
| @Nullable 字段标记了这个注解,说明这个字段可以为null
|
1 2 3
| public @interface Autowired { boolean required() defalut true; }
|
测试代码:
1 2 3 4 5 6 7
| public class People { @Autowired(required = false) private Cat cat; private Dog dog; private String name; }
|
如果@Autowired 自动装配的环境比较复杂,自动装配无法通过一个注解【@Autowired】完成的时候,我们可以使用@Qualifier(value=”xxx”)去配置@Autowired的使用,指定一个唯一的bean对象注入
1 2 3 4 5 6 7 8 9
| public class People { @Autowired @Qualifier(value="cat11") private Cat cat; @Autowired @Qualifier(value="dog222") private Dog dog; private String name; }
|
@Resource 注解
1 2 3 4 5 6 7
| public class People { @Resource(value = "cat2") private Cat cat; @Resource private Dog dog }
|
小结:
@Resource 和 @Autowired 的区别:
- 都是用来自动装配的,都可以放在属性字段上
- @Autowired 通过 byType 的方式实现,而且必须要求这个对象存在!【常用】
- @Resource 默认通过byName的方式实现,如果找不到名字,则通过byType实现!如果两个都找不到的情况下,就报错【常用】
- 执行顺序不同:@Autowired 通过byType的方式实现, @Resource 通过byName的方式实现
8. 使用注解开发
在spring 4之后,要使用注解开发,一定要确认aop包导入了

使用注解要导入context 的约束
1 2 3 4 5 6 7 8 9 10 11
| <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config /> </beans>
|
bean
属性如何注入
1 2 3 4 5 6 7 8 9 10
| @Component public class User { public String name; @Value("raehp") public void setName(String name) { this.name = name } }
|
注解的衍生
@Component 有几个衍生注解,我们在web开发中,会按照mvc三层架构分层!
- dao 【@Reposity】
- service 【@Service】
- controller【@Controller】
这四个注解功能都是一样的,都是代表将某个类注册到Spring中,装配Bean
自动装配
1 2 3 4
| - @Autowired:自动装配通过类型,名字 如果Autowired不能唯一自动装配上属性,则需要通过@Qualifier(value="xxx") - @Nullable 字段标记了这个注解,说明这个字段可以为null - @Resource:自动装配通过名字。类型
|
作用域
1 2 3 4 5 6 7 8 9 10 11
| @Component @Scope("prototype") public class User{ public String name; @Value("raehp") public void setName(String name) { this.name = name } }
|
小结
xml于注解:
- xml更加万能,适用于任何场合!维护简单方便
- 注解不是自己类使用不了,维护相对复杂
xml 与 注解最佳实践:
9. 使用Java的方式配置Spring
我们现在要完全不适用Spring的xml配置了,全权交给Java来做!
JavaConfig 是Spring 的一个子项目,在Spring 4 之后,他成为了一个核心功能!

实体类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
| package org.raehp.pojo;
import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component;
@Component public class User { private String name;
public String getName() { return name; }
@Value("kkkkkk") public void setName(String name) { this.name = name; }
@Override public String toString() { return "User{" + "name='" + name + '\'' + '}'; } }
|
配置类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
| package org.raehp.config;
import org.raehp.pojo.User; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration;
@Configuration @ComponentScan("org.raehp.pojo") public class JavaConfig { @Bean public User getUser() { return new User(); } }
|
测试类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
| package org.raehp;
import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; import org.raehp.config.JavaConfig; import org.raehp.pojo.User; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AppTest { public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfig.class); User user = (User) context.getBean("getUser"); System.out.println(user.getName()); } }
|
10. 代理模式
10.1 静态代理
角色分析:
- 抽象角色:一般会使用接口活着抽象类来解决
- 真实角色:被代理的角色
- 代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作
- 客户:访问代理对象的人

代码步骤
接口
1 2 3 4 5 6
| package org.raehp.demo01;
public interface rent { public void rent(); }
|
真实角色
1 2 3 4 5 6 7 8 9
| package org.raehp.demo01;
public class Host implements rent{ @Override public void rent() { System.out.println("房东出租房子"); } }
|
代理角色
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
| package org.raehp.demo01;
public class proxy implements rent{
private Host host;
public proxy() { }
public proxy(Host host) { this.host = host; }
@Override public void rent() { System.out.println("房东出租房子"); }
public void seeHouse() { System.out.println("房东带你看房"); }
public void fee() { System.out.println("收中介费"); }
public void writeHT() { System.out.println("签合同"); } }
|
客户端访问代理角色
1 2 3 4 5 6 7 8 9 10 11 12 13
| package org.raehp.demo01;
public class client { public static void main(String[] args) { Host host = new Host(); proxy proxy = new proxy(host); proxy.rent(); } }
|
代理模式的好处:
- 可以使真实角色的操作更加纯粹,不用去关注一些公共的业务
- 公共也就交代给代理角色!实现了业务的分工!
- 公共业务发生扩展的时候,方便集中管理!
缺点:
- 一个真实角色就会产生一个代理角色;代码量会翻倍开发效率会变低!
10.2 动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的,不是我们直接写好的
- 动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口 — JDK 动态代理 【我们在这里使用】
- 基于类:cglib
- java字节码实现:javasist、
需要了解两个类:
- Proxy:代理
- InvocationHandler:调用处理程序
实现:
ProxyInvocationHandler类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
| package org.raehp.demo03;
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;
public void setTarget(Object target) { this.target = target; }
public Object getTarget() { return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this); }
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { log(method.getName()); Object result = method.invoke(target, args); return result; }
public void log(String msg) { System.out.println("调用了" + msg + "方法"); } }
|
测试类
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| package org.raehp.demo03;
public class client { public static void main(String[] args) { UserServiceImpl userService = new UserServiceImpl(); ProxyInvocationHandler pih = new ProxyInvocationHandler(); pih.setTarget(userService); UserService proxy = (UserService) pih.getTarget(); proxy.query(); } }
|
结果
动态代理的好处:
- 可以使真实角色的操作更加纯粹,不用去关注一些公共的业务
- 公共也就交代给代理角色!实现了业务的分工!
- 公共业务发生扩展的时候,方便集中管理!
- 一个动态代理类代理的是一个接口,一般就是对应的一类义务
- 一个动态代理类可以代理多个类,只要是实现了同一个接口即可
11. AOP
11.1 什么是AOP
AOP (Aspect Oriented Programming)意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。


11.2 AOP在Spring中的应用
==提供声明式事务:允许用户自定义切面==
横切关注点:跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志,安全,缓存,事务等等 ..
- 切面(ASPECT):横切关注点 被模块化 的特殊对象。即,它是一个类.
- 通知(Advice):切面必须要完成的工作。即,它是类中的一个方法。
- 目标(Target):被通知对象。
- 代理(Proxy):向目标对象应用通知之后创建的对象。
- 切入点(Pointcut):切面通知 执行的“地点”的定义。
- 连接点(JointPoint):与切入点匹配的执行点。

11.3 使用Spring实现AOP
11.3.1 方式一:使用spring 的api接口
导入aop的依赖
1 2 3 4 5
| <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.7</version> </dependency>
|
Log类
1 2 3 4 5 6 7 8 9 10 11 12
| package org.raehp.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice { @Override public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println(target.getClass().getName() + "的" + method.getName() + "方法运行了"); } }
|
AfterLog类
1 2 3 4 5 6 7 8 9 10 11 12
| package org.raehp.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice { @Override public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { System.out.println(target.getClass().getName() + "的" + method.getName() + "方法执行了" + "返回了" + returnValue); } }
|
application.xml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
| <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="log" class="org.raehp.log.Log" /> <bean id="afterLog" class="org.raehp.log.AfterLog" /> <bean id="userService" class="org.raehp.service.UserServiceImpl" />
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* org.raehp.service.UserServiceImpl.*(..))"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor> <aop:advisor advice-ref="log" pointcut-ref="pointcut"></aop:advisor> </aop:config> </beans>
|
11.3.2 自定义类来实现aop
diyPointCut【主要是切面定义】
1 2 3 4 5 6 7 8 9 10 11
| package org.raehp.diy;
public class DiyPointCut { public void before () { System.out.println("方法执行前执行"); }
public void after () { System.out.println("方法执行后执行"); } }
|
application.xml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
| <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <bean id="userService" class="org.raehp.service.UserServiceImpl" /> <bean id="diy" class="org.raehp.diy.DiyPointCut" /> <aop:config> <aop:aspect ref="diy"> <aop:pointcut id="point" expression="execution(* org.raehp.service.UserServiceImpl.*(..))"/> <aop:before method="before" pointcut-ref="point" /> <aop:after method="after" pointcut-ref="point" /> </aop:aspect> </aop:config>
|
11.3.3 使用注解配置aop
application.xml
1 2 3 4 5 6 7 8 9 10 11 12 13
| <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 方式三:注解--> <bean id="AnnotationPointCut" class="org.raehp.Annotation.AnnotationPointCut" /> <!-- 开启注解支持! JDK(默认 proxy-target-class="false") cglib(proxy-target-class="true")--> <aop:aspectj-autoproxy />
|
AnnotationPointCut
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
| package org.raehp.Annotation;
import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before;
@Aspect public class AnnotationPointCut {
@Before("execution(* org.raehp.service.UserServiceImpl.*(..))") public void before () { System.out.println("方法执行前执行"); }
@After("execution(* org.raehp.service.UserServiceImpl.*(..))") public void after () { System.out.println("方法执行后执行"); } }
|
12. 整合Mybatis
步骤:
- 导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关的
- aop植入
- mybatis-spring 【new】
- 编写配置文件
- 测试
导入maven依赖
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
| <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.32</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.9</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>6.1.8</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.2.10.RELEASE</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.7</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.7</version> </dependency>
|
12.1 回忆mybatis
- 编写实体类
- 编写核心配置文件
- 编写接口
- 编Mapper.xml
- 测试
UserMapper.interface
1 2 3 4 5 6 7 8 9
| package org.raehp.mapper;
import org.raehp.pojo.User;
import java.util.List;
public interface UserMapper { public List<User> selectUser(); }
|
UserMapper.xml
1 2 3 4 5 6 7 8 9 10
| <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.raehp.mapper.UserMapper"> <select id="selectUser" resultType="user"> select * from user; </select> </mapper>
|
mybatis-config.cml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
| <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration>
<typeAliases> <package name="org.raehp.pojo"/> </typeAliases> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"></transactionManager> <dataSource type="POOLED"> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/student"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> </environment> </environments>
<mappers> <mapper class="org.raehp.mapper.UserMapper" /> </mappers> </configuration>
|
Test类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
| package org.raehp;
import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import org.junit.Test; import org.raehp.mapper.UserMapper; import org.raehp.pojo.User;
import java.io.IOException; import java.io.InputStream; import java.util.List;
public class AppTest { @Test public void test() throws IOException { String resource = "mybatis-config.xml"; InputStream in = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in); SqlSession sqlSession = sqlSessionFactory.openSession(true);
UserMapper mapper = sqlSession.getMapper(UserMapper.class); List<User> userList = mapper.selectUser();
for (User user : userList) { System.out.println(user); } } }
|