Spring整理笔记（狂神说Spring整理笔记）
1.Spring
1.1简介
1.2 优点
1.3 组成
2.IOC
2.1 IOC组成理论推导
2.2 IOC本质
2.3 IOC创建对象的方式
3.Spring的基础配置
3.1 别名
3.2 Bean的配置
3.3 import
4.DI依赖注入
4.1 构造器注入
4.2 set方式注入 【重点】
4.3 p、c 标签注入
4.4 Bean的作用域
5 Bean的自动装配
5.1 byName与byType自动装配
5.2 使用注解实现自动装配
5.3 @Autowired与@Resource
5.4 使用注解开发
5.5 使用java的方式配置Spring
6 代理模式
6.1静态代理
6.2 动态代理
7.AOP
7.1 什么是AOP
7.2 Aop在Spring中的作用
7.3 使用Spring实现Aop
8.整合Mybatis
8.1整合Mybatis方式一
8.1整合Mybatis方式二
9.Spring配置声明事务注入
10.致谢
1.Spring
1.1简介
Spring：春天 给软件行业带来了春天
2002，首次推出了Spring框架的雏形：interface21框架
Spring框架即是以interface21框架为基础经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版
Rod Johnson Spring Framework创始人，著名作者。 Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。 有着相当丰富的C/C++技术背景的Rod早在1996年就开始了对Java服务器端技术的研究
Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
SSH :Struct2 + Spring + Hibernate
SSM：SpringMVC + SPring +Mybatis
官网：https://spring.io/
官方下载地址：http://repo.spring.io/release/org/springframework/spring
GitHub：https://github.com/spring-projects/spring-framework
Spring核心技术地址：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-annotation-config
1.2 优点
Spring是一个开源的免费的框架（容器）！
Spring是一个轻量级的，非入侵式的框架
控制反转（IOC），面向切面编程（AOP）
支持事务的处理，对框架整合的支持！
Spring就是一个轻量级的控制反转（IOC）和切面编程（AOP）的框架！
1.3 组成
2.IOC
2.1 IOC组成理论推导
原来的实现方式
1.UserDao接口
public interface UserDao {
void getUser();
}
1
2
3
2.UserDaoImpl实现类
public class UserDaoImpl implements UserDao{
public void getUser() {
System.out.println(“默认获取用户的数据”);
}
}
1
2
3
4
5
3.UserService业务接口
public interface UserService {
void getUser();
}
1
2
3
4.UserServiceImpl实现类
public class UserServiceImpl implements UserService{
private UserDao userDao = new UserDaoImpl();
public void getUser() {
userDao.getUser();
}
}
1
2
3
4
5
6
7
8
如果想要改变，就需要每次更改UserDao
若将UesrDao使用Set接口实现
public class UserServiceImpl implements UserService{
private UserDao userDao;
//利用set进行动态实现值得注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void getUser() {
userDao.getUser();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
之前，程序通过new主动创建对象！控制权在程序猿手上
使用set注入后，程序不再具有主动性，而是变成了被动的接受对象！
这种思想，从本质上解决了问题，程序员不用再去管理对象的创建了，降低了耦合性！
2.2 IOC本质
控制反转IOC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IOC的一种方法， 也有人认为DI只是IOC的另一种说法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓的控制反转就是：获得依赖的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（xml或注解）并通过第三方去生产或获取特定对象的方式。在spring中实现控制反转的是IOC容器，其实现方法是依赖注入（Dependency Injection，DI）
xml文件
<?xml version="1.0" encoding="UTF-8"?><!--使用Spring来创建对象，在Spring这些都称为Bean-->
<bean id="hello" class="com.yang.entity.Hello">
<property name="name" value="spring"/>
</bean>
package com.yang.entity;
public class Hello {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Hello{" +
"name='" + name + '\'' +
'}';
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
测试
import com.yang.entity.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
//获取spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在spring中管理，我们要使用，直接去里面取出来
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
会发现，已经不需要手动new对象，对象是在xml文件中配置。或者通俗来讲，不需要改底层代码，而xml文件不算底层代码。
控制反转
控制： 谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的
反转: 程序本身不创建对象，而变成被动的接收对象。
依赖注入： 就是利用set方法来进行注入的
IOC是一种编程思想，由主动的编程变为被动的接收，所谓的IOC，即对象由Spring来创建，管理，装配
2.3 IOC创建对象的方式
默认使用无参构造创建对象
使用有参构造创建对象的三种方式
public class User {
private String name;
private int age;
public User(String name, int age) {this.name = name;this.age = age;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
}
1
2
3
4
5
6
7
8
9
10
a.下标赋值 Constructor argument index
<bean id="user" class="com.yang.entity.User">
<constructor-arg index="0" value="张三"/>
<constructor-arg index="1" value="18"/>
</bean>
1
2
3
4
b.变量类型赋值 Constructor argument type matching
<bean id="user1" class="com.yang.entity.User">
<constructor-arg type="int" value="18"/>
<constructor-arg type="java.lang.String" value="张三"/>
</bean>
1
2
3
4
c.变量名称赋值 Constructor argument name
<bean id="user2" class="com.yang.entity.User">
<constructor-arg name="name" value="张三"/>
<constructor-arg name="age" value="18"/>
</bean>
1
2
3
4
在获取spring的上下文对象（ new ClassPathXmlApplicationContext(“beans.xml”); ）时，spring容器中的所有的对象就已经被创建了。
3.Spring的基础配置
3.1 别名
1
2
3.2 Bean的配置
1
2
3
4
5
6
7
8
9
3.3 import
import，一般用于团队开发使用，他可以将多个配置文件，导入合并为1个
假设，现在项目中又多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以用import将所有人的beans.xml合并为一个总的！
appliacationContext1.xml
appliacationContext2.xml
appliacationContext3.xml
合并
1
4.DI依赖注入
4.1 构造器注入
4.2 set方式注入 【重点】
依赖注入
依赖：bean对象的创建依赖于容器
注入：bean对象中的所有属性，由容器来注入
【环境搭建】
1.复杂类型
package com.yang.entity;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2.真实测试对象
package com.yang.entity;
import java.util.*;
public class Student {
private String name;
private Address address;
private String [] books;
private List<String> hobbies;
private Map<String, String> card;
private Set<String> games;
private String wife;
private Properties info;
//以及Getter与Setter方法
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
3.applicationContext.xml
<bean id="address" class="com.yang.entity.Address">
<property name="address" value="Dalian"/>
</bean>
<!--第一种 普通注入 value-->
<bean id="student" class="com.yang.entity.Student">
<property name="name" value="yang"/>
<!--第二种 Bean注入， ref-->
<property name="address" ref="address"/>
<!--数组-->
<property name="books">
<array>
<value>红楼梦</value>
<value>三国演义</value>
<value>水浒传</value>
<value>西游记</value>
</array>
</property>
<!--List-->
<property name="hobbies">
<list>
<value>抽烟</value>
<value>喝酒</value>
<value>烫头</value>
</list>
</property>
<!--Map-->
<property name="card">
<map>
<entry key="身份证" value="220......."/>
<entry key="银行卡" value="626......."/>
</map>
</property>
<!--Set-->
<property name="games">
<set>
<value>LOL</value>
<value>COC</value>
<value>BOB</value>
</set>
</property>
<!--null-->
<property name="wife">
<null/>
</property>
<!--Properties-->
<property name="info">
<props>
<prop key="driver">驱动</prop>
<prop key="name">root</prop>
<prop key="password">123456</prop>
</props>
</property>
</bean>
import com.yang.entity.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) context.getBean("student");
System.out.println(student);
/*
* Student{
* name='yang',
* address=Address{address='Dalian'},
* books=[红楼梦, 三国演义, 水浒传, 西游记],
* hobbies=[抽烟, 喝酒, 烫头],
* card={身份证=220......., 银行卡=626.......},
* games=[LOL, COC, BOB],
* wife='null',
* info={password=123456, name=root, driver=驱动}}
* */
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
4.3 p、c 标签注入
官方
p标签注入，须在beans中引入 xmlns:p=“http://www.springframework.org/schema/p”
<?xml version="1.0" encoding="UTF-8"?>
1
2
3
4
5
6
7
8
c标签注入，需在实体中增加有参构造方法，并引入 xmlns:c=“http://www.springframework.org/schema/c”
<!--c命名空间注入，通过构造器注入：construct-args-->
<bean id="c_test" class="com.yang.entity.Address" c:address="DL"/>
1
2
3
4
5
6
7
8
9
10
4.4 Bean的作用域
1.单例模式（Spring默认机制）
2.原型模式：每次从容器中get对象时，都重新创建
13.其余的request、session、application、websocket这些只能在web开发中使用
5 Bean的自动装配
自动装配是spring满足bean依赖的一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性
在Spring中由三种装配方式
在xml中显式配置
在java中显式配置
隐式的自动装配bean
5.1 byName与byType自动装配
<bean id="cat" class="com.yang.entity.Cat"/>
<bean id="dog" class="com.yang.entity.Dog"/>
<!--
byName:会在容器上下文中查找，和自己对象set方法后面的值相对应的beanid
byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean
-->
<bean id="people" class="com.yang.entity.People" autowire="byName">
<property name="name" value="yang"/>
</bean>
<bean id="people1" class="com.yang.entity.People" autowire="byType">
<property name="name" value="yang"/>
</bean>
5.2 使用注解实现自动装配
jdk1.5支持的注解 Spring2.5支持的注解
The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML
使用注解须知：
1.导入约束：context约束
（xmlns:context=“http://www.springframework.org/schema/context”
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd）
2.配置注解的支持context:annotation-config
context:annotation-config/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
5.3 @Autowired与@Resource
@Autowired
直接在属性上使用即可！也可以在set方式上使用
使用Autowired我们可以不用编写set方法了，前提是你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byName
科普:
@Nullable 字段标记了这个注解，说明这个字段可以为null；
public class People {
//如果定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
private String name;
1
2
3
4
5
6
7
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier（value = “xxx”）去配置@Autowired的使用，指定一个唯一的bean对象注入！
public class People {
//如果定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
@Qualifier(value = “xxx”)
private Dog dog;
private String name;
}
1
2
3
4
5
6
7
8
9
@Resource注解，不指定name值，先去判断byName和byType，有一个能注入即成功
public class People {
@Resource(name = “xxxx”)
private Cat cat;
1
2
3
小结：@Resource和@Autowired的区别
都是用来自动装配的，都可以放在属性字段上
@Autowired通过byType的方式实现，而且必须要求这个对象存在！
@Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！
执行顺序不同：@Autowired通过byType的方式实现。@Resource默认通过byName的方式实现。
5.4 使用注解开发
在Spring4之后，要使用注解开发，必须保证aop的包导入了
使用注解需要导入context约束，增加注解的支持！
<?xml version="1.0" encoding="UTF-8"?><!--开启注解支持-->
<context:annotation-config/>
<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.yang"/>
//@Component 等价于
@Component
public class User {
String name;
}
1
2
3
4
5
2. 属性注入使用@Value注解
//@Component 等价于
@Component
public class User {
String name;
//@Value("yang") 相当于<property name="name" value="yang"/>
@Value("yang")
public void setName(String name) {
this.name = name;
}
}
1
2
3
4
5
6
7
8
9
10
11
3. 衍生注解
@Componet有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
dao层 【@Repository】
service层 【@Service】
controller层 【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
4.自动装配
@Autowired 自动装配通过类型、名字
如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value=“xxx”)
@Nullable 字段标记了这个注解，说明这个字段可以为null
@Resource 自动装配通过名字，类型
1
2
3
4
5. 作用域
@Scope(“singleton”)单例
- 小结
XML 与 注解
xml更加万能，适用于任何场合！维护简单方便
注解不是自己类使用不了， 维护相对复杂
XML 与 注解最佳实践
xml用来管理bean
注解只负责完成属性的注入
我们在使用过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持
context:annotation-config/
<context:component-scan base-package=“com.yang”/>
1
2
3
4
5.5 使用java的方式配置Spring
实体类
package com.yang.entity;
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("Yang")
public void setName(String name) {
this.name = name;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
配置类
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
//@Configuration,这个也会被Spring容器托管，注册到容器中，因为打开注解，它本身就被定义为组件了@Component
//@Configuration该注解代表了这是一个配置类，与applicationContext.xml一样
@Configuration
@ComponentScan(“com.yang.entity”)
@Import(YangConfig2.class)
public class YangConfig {
//注册一个Bean，就相当于我们之前写的一个bean标签
//方法名字 == bean标签的id
//方法的返回值 == bean标签中的class属性
@Bean
public User getUser () {
return new User();//就是返回要注入到bean的对象
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
测试类
public class MyTest {
public static void main(String[] args) {
ApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(YangConfig.class);
User getUser = (User)annotationConfigApplicationContext.getBean("getUser");
System.out.println(getUser.getName());
}
}
1
2
3
4
5
6
7
8
9
6 代理模式
6.1静态代理
角色分析：
抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
客户：访问代理对象的人
代码步骤：
接口
真实角色
代理角色
客户端访问代理角色
具体代码可参考：多线程中的静态代理
代理模式的好处：
可以使真实角色的操作更加存粹！不用去关注一些公共的业务
公共交给了代理角色，实现了业务的分工
公共业务发生扩展的时候，方便集中管理
缺点：
一个真实角色就会产生一个代理角色，代码量会翻倍 开发效率变低
6.2 动态代理
动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
基于接口：JDK动态代理
基于类： cglib
java字节码实现： javasist
需要了解两个类：Proxy：代理 InvocationHandler：调用处理程序
Proxy
java.lang.reflect.Proxy
Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。(大白话：这是一个静态类，类里边有方法得到代理类)
动态代理类 （以下简称为代理类 ）是一个实现在类创建时在运行时指定的接口列表的类，具有如下所述的行为。 代理接口是由代理类实现的接口。 代理实例是代理类的一个实例。 每个代理实例都有一个关联的调用处理程序对象，它实现了接口InvocationHandler 。 通过其代理接口之一的代理实例上的方法调用将被分派到实例调用处理程序的invoke方法，传递代理实例， java.lang.reflect.Method被调用方法的java.lang.reflect.Method对象以及包含参数的类型Object Object的数组。 调用处理程序适当地处理编码方法调用，并且返回的结果将作为方法在代理实例上调用的结果返回。
代理类具有以下属性：
代理类是公共的，最终的，而不是抽象的，如果所有代理接口都是公共的。
如果任何代理接口是非公开的，代理类是非公开的，最终的，而不是抽象的 。
代理类的不合格名称未指定。 然而，以字符串"$Proxy"开头的类名空间应该保留给代理类。
一个代理类扩展了java.lang.reflect.Proxy 。
代理类完全按照相同的顺序实现其创建时指定的接口。
如果一个代理类实现一个非公共接口，那么它将被定义在与该接口相同的包中。 否则，代理类的包也是未指定的。 请注意，程序包密封不会阻止在运行时在特定程序包中成功定义代理类，并且类也不会由同一类加载器定义，并且与特定签名者具有相同的包。
由于代理类实现了在其创建时指定的所有接口， getInterfaces在其类对象上调用getInterfaces将返回一个包含相同列表接口的数组（按其创建时指定的顺序），在其类对象上调用getMethods将返回一个数组的方法对象，其中包括这些接口中的所有方法，并调用getMethod将在代理接口中找到可以预期的方法。
Proxy.isProxyClass方法将返回true，如果它通过代理类 - 由Proxy.getProxyClass返回的类或由Proxy.newProxyInstance返回的对象的类 - 否则为false。
所述java.security.ProtectionDomain代理类的是相同由引导类装载程序装载系统类，如java.lang.Object ，因为是由受信任的系统代码生成代理类的代码。 此保护域通常将被授予java.security.AllPermission 。
每个代理类有一个公共构造一个参数，该接口的实现InvocationHandler ，设置调用处理程序的代理实例。 而不必使用反射API来访问公共构造函数，也可以通过调用Proxy.newProxyInstance方法来创建代理实例，该方法将调用Proxy.getProxyClass的操作与调用处理程序一起调用构造函数。
//为某个接口创建代理Foo ：
InvocationHandler handler = new MyInvocationHandler(…);
Class<?> proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class);
Foo f = (Foo) proxyClass.getConstructor(InvocationHandler.class).
newInstance(handler);
//或更简单地：
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
new Class<?>[] { Foo.class },
handler);
1
2
3
4
5
6
7
8
9
public static 类<?> getProxyClass(ClassLoader loader,
类<?>… interfaces)
throws IllegalArgumentException
/*给定类加载器和接口数组的代理类的java.lang.Class对象。 代理类将由指定的类加载器定义，并将实现所有提供的接口。 如果任何给定的接口是非公开的，则代理类将是非公开的。 如果类加载器已经定义了接口相同置换的代理类，那么将返回现有的代理类; 否则，这些接口的代理类将被动态生成并由类加载器定义。
对可能传递给Proxy.getProxyClass的参数有几个Proxy.getProxyClass ：
interfaces数组中的所有类对象都必须表示接口，而不是类或原始类型。
interfaces数组中没有两个元素可能是指相同的类对象。
所有的接口类型必须通过指定的类加载器的名称可见。 换句话说，对于类加载器cl和每个接口i ，以下表达式必须为真：
Class.forName(i.getName(), false, cl) == i 所有非公共接口必须在同一个包中; 否则代理类将不可能实现所有接口，而不管其中定义了什么包。
对于具有相同签名的指定接口的任何成员方法集合：
如果任何方法的返回类型是原始类型或void，则所有方法必须具有相同的返回类型。
否则，其中一个方法必须具有一个返回类型，该类型可以分配给其余方法的所有返回类型。
生成的代理类不能超过虚拟机对类施加的任何限制。 例如，VM可以将类可以实现的接口数量限制为65535; 在这种情况下， interfaces阵列的大小不得超过65535。
如果任何这些限制被违反， Proxy.getProxyClass将抛出一个IllegalArgumentException 。 如果interfaces数组参数或其任何元素为null ，则将抛出一个NullPointerException 。
请注意，指定的代理接口的顺序是重要的：具有相同组合的接口但不同顺序的代理类的两个请求将导致两个不同的代理类。
参数
loader - 类加载器来定义代理类
interfaces - 要实现的代理类的接口列表
结果
在指定的类加载器中定义并实现指定接口的代理类 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static Object newProxyInstance(ClassLoader loader,
类<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
/*返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。
Proxy.newProxyInstance因为与IllegalArgumentException相同的原因而Proxy.getProxyClass 。
参数
loader - 类加载器来定义代理类
interfaces - 代理类实现的接口列表
h - 调度方法调用的调用处理函数
结果
具有由指定的类加载器定义并实现指定接口的代理类的指定调用处理程序的代理实例 */
1
2
3
4
5
6
7
8
9
10
11
12
13
InvocationHandler
InvocationHandler是由代理实例的调用处理程序实现的接口 。
每个代理实例都有一个关联的调用处理程序。 当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。
invoke(Object proxy, 方法 method, Object[] args) 处理代理实例上的方法调用并返回结果。
Object invoke(Object proxy,
方法 method,
Object[] args)
throws Throwable处理代理实例上的方法调用并返回结果。 当在与之关联的代理实例上调用方法时，将在调用处理程序中调用此方法。
/*参数
proxy - 调用该方法的代理实例
method -所述方法对应于调用代理实例上的接口方法的实例。 方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。 原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。
结果
从代理实例上的方法调用返回的值。 如果接口方法的声明返回类型是原始类型，则此方法返回的值必须是对应的基本包装类的实例; 否则，它必须是可声明返回类型的类型。 如果此方法返回的值是null和接口方法的返回类型是基本类型，那么NullPointerException将由代理实例的方法调用抛出。 如上所述，如果此方法返回的值，否则不会与接口方法的声明的返回类型兼容，一个ClassCastException将代理实例的方法调用将抛出。
异常
Throwable - 从代理实例上的方法调用抛出的异常。 异常类型必须可以分配给接口方法的throws子句中声明的任何异常类型java.lang.RuntimeException检查的异常类型java.lang.RuntimeException或java.lang.Error 。 如果检查的异常是由这种方法是不分配给任何的中声明的异常类型throws接口方法的子句，则一个UndeclaredThrowableException包含有由该方法抛出的异常将通过在方法调用抛出代理实例。 */
1
2
3
4
5
6
7
8
9
10
11
12
编写实例
接口
package com.yang.demo;
public interface UserServiceInterface {
public void add();
public void delete();
public void update();
public void select();
}
1
2
3
4
5
6
7
接口实现类
package com.yang.demo;
public class UserServiceImpl implements UserServiceInterface{
public void add() {
System.out.println(“增加一个用户”);
}
public void delete() {
System.out.println(“删除一个用户”);
}
public void update() {
System.out.println(“更新一个用户”);
}
public void select() {
System.out.println(“检索一个用户”);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
创建代理工具类
package com.yang.demo;
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;
}
//重写的InvocationHandler中的invoke方法
//处理代理实例，并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
Object invoke = method.invoke(target, args);
return invoke;
}
//生成得到代理类
public Object getProxy () {
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}
public void log (String msg) {
System.out.println("执行了" + msg + "方法");
}
}
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
测试类
package com.yang.demo;
public class Client {
public static void main(String[] args) {
//真实角色
UserServiceImpl userService = new UserServiceImpl();
//代理角色，不存在
ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
//设置要代理的对象
proxyInvocationHandler.setTarget(userService);
//注意要用接口强转，否则会报异常
UserServiceInterface proxy = (UserServiceInterface)proxyInvocationHandler.getProxy();
proxy.add();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
7.AOP
7.1 什么是AOP
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
7.2 Aop在Spring中的作用
提供生命事务：允许用户自定义切面
横切关注点：跨越应用程序多个模块的方法或功能。即与我们的业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等。。。
切面（ASPECT）：横切关注点 被模块化的特殊对象。即 它是一个类
通知（Advice）：切面必须要完成的工作，即 他是类中的一个方法
目标（target）：被通知的对象
代理（Proxy）：向目标对象应用通知之后创建的对象
切入点（PointCut）：切面通知 执行的"地点"的定义
连接点（jointPoint）：与切入点匹配的执行点
SpringAop中，通过Advice定义横切逻辑，Spring中支持的5种类型的Advice
7.3 使用Spring实现Aop
【重点】使用AOP织入，需要依赖包
UserServer接口
package com.yang.service;
public interface UserService {
public void add();
public void update();
public void delete();
public void select();
}
1
2
3
4
5
6
7
UserServer实现类
package com.yang.service;
public class UserServiceImpl implements UserService{
public void add() {
System.out.println(“增加了一个用户”);
}
public void update() {
System.out.println(“更新了一个用户”);
}
public void delete() {
System.out.println(“删除了一个用户”);
}
public void select() {
System.out.println(“检索了一个用户”);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Log类
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice, AfterReturningAdvice {
//method:要执行的目标对象的方法（method being invoked）
//object:参数（args: arguments to the method）
//o:目标对象 （target：target of the method invocation）
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName() + “的” + method.getName() + “被执行了”);
}
//returnValue:返回值
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println(“执行了” + method.getName() + “方法，返回值为” + returnValue);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
配置文件
<!--注册bean-->
<bean id="userService" class="com.yang.service.UserServiceImpl"/>
<bean id="log" class="com.yang.log.Log"/>
<!--方式：使用原生Spring Api接口-->
<!--配置aop-->
<aop:config>
<!--切入点：execution:表达式，execution(*(修饰词) *(返回值) *(类名) *(方法名) *(参数)) ..任意参数-->
<aop:pointcut id="pointcut" expression="execution(* com.yang.service.UserServiceImpl.*(..))"/>
<!--执行环绕增加-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
</aop:config>
import com.yang.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext(“applicationContext.xml”);
UserService userService = classPathXmlApplicationContext.getBean(“userService”, UserService.class);
userService.add();
}
}
1
2
3
4
5
6
7
8
9
10
方式二：自定义来实现AOP【主要是切面定义】
<!--注册bean-->
<bean id="userService" class="com.yang.service.UserServiceImpl"/>
<bean id="log" class="com.yang.log.Log"/>
<bean id="diy" class="com.yang.diy.DiyPointCut"/>
<!--方式2：自定义类-->
<aop:config>
<!--<aop:aspect ref="diy"> : 标注这个类为切面-->
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id="point" expression="execution(* com.yang.service.UserServiceImpl.*(..))"/>
<!--通知-->
<aop:before method="beforeMethod" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
package com.yang.diy;
public class DiyPointCut {
public void beforeMethod () {
System.out.println(“方法执行之前”);
}
}
1
2
3
4
5
6
方式三：使用注解实现AOP
XML文件
<!--注册bean-->
<bean id="userService" class="com.yang.service.UserServiceImpl"/>
<!--方式3：使用注解-->
<!--开启注解支持 JDK（默认proxy-target-class="false"）cglib默认proxy-target-class="true"）-->
<aop:aspectj-autoproxy proxy-target-class="false"/>
<bean id="annotationPointCut" class="com.yang.diy.AnnotationPointcut"/>
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class AnnotationPointcut {
@Before(“execution(* com.yang.service.UserServiceImpl.(…))")
public void before () {
System.out.println(“方法执行前”);
}
@After("execution( com.yang.service.UserServiceImpl.(…))")
public void after () {
System.out.println(“方法执行后”);
}
//在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
@Around("execution( com.yang.service.UserServiceImpl.*(…))”)
public void around (ProceedingJoinPoint pjp) throws Throwable {
System.out.println(“环绕前”);
Signature signature = pjp.getSignature();//获得签名
System.out.println(“signature” + signature);
Object proceed = pjp.proceed();//执行方法
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
8.整合Mybatis
8.1整合Mybatis方式一
步骤：
导入相关jar包
junit
mybatis
mysql数据库
spring相关的
aop织入
mybatis-spring
spring-study
com.yang
1.0-SNAPSHOT
4.0.0
<artifactId>spring-10-mybatis</artifactId>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!--Spring操作数据库的话，还需要一个spring-jdbc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.8.13</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.10</version>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能使用构造器注入sqlSessionFactory，因为没有set方法-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
测试
实体类
package com.yang.entity;
import lombok.Data;
@Data
public class User {
private int id;
private String name;
private int pwd;
}
1
2
3
4
5
6
7
8
mapper接口
package com.yang.mapper;
import com.yang.entity.User;
import java.util.List;
public interface UserMapper {
public List selectUser();
}
1
2
3
4
5
6
7
mapper实现类
package com.yang.mapper;
import com.yang.entity.User;
import org.mybatis.spring.SqlSessionTemplate;
import java.util.List;
public class UserMapperImpl implements UserMapper{
//我们的所有操作，原来都是用sqlSession来执行，现在都是用sqlSessionTemplate
private SqlSessionTemplate sqlSessionTemplate;
public void setSqlSessionTemplate (SqlSessionTemplate sqlSessionTemplate) {
this.sqlSessionTemplate = sqlSessionTemplate;
}
public List<User> selectUser() {
UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
return mapper.selectUser();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
mapper映射文件
import com.yang.entity.User;
import com.yang.mapper.UserMapper;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void test () throws IOException {
ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext(“applicationContext.xml”);
UserMapper userMapper = classPathXmlApplicationContext.getBean("userMapper", UserMapper.class);
List<User> userList = userMapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
8.1整合Mybatis方式二
SqlSessionDaoSupport
SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。调用 getSqlSession() 方法你会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法，就像下面这样:
package com.yang.mapper;
import com.yang.entity.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
public List selectUser() {
SqlSession sqlSession = getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List users = mapper.selectUser();
//return getSqlSession().getMapper(UserMapper.class).selectUser();
return users;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
实际上是整合mybatis一与整合mybatis二是一样的方法，只不过二继承了SqlSessionDaoSupport ，在getSqlSession()，做的也是setSqlSessionTemplate
9.Spring配置声明事务注入
<?xml version="1.0" encoding="UTF-8"?><import resource="spring-dao.xml"/>
<bean id="userMapper" class="com.yang.mapper.UserMapperImpl2">
<property name="sqlSessionTemplate" ref="sqlSession"/>
</bean>
<!--配置声明事务注入-->
<!--要开启 Spring 的事务处理功能，在 Spring 的配置文件中创建一个 DataSourceTransactionManager 对象：-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
<!--或者使用构造注入-->
<!--<constructor-arg ref="dataSource" />-->
</bean>
<!--结合AOP实现事务的织入-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--给哪些方法配置事务-->
<!--配置事务的传播特性 propagation
PROPAGATION_REQUIRED:如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
PROPAGATION_SUPPORTS:支持当前事务，如果没有当前事务，就以非事务方法执行。
PROPAGATION_MANDATORY:使用当前事务，如果没有当前事务，就抛出异常。
PROPAGATION_REQUIRES_NEW:新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER:以非事务方式执行操作，如果当前事务存在则抛出异常。
PROPAGATION_NESTED: 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED 类似的操作
-->
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="select" read-only="true"/>
<!--全部方法-->
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!--配置事务切入-->
<aop:config>
<!--该包下的所有方法-->
<aop:pointcut id="txPointCut" expression="execution(* com.yang.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>