Spring学习笔记总结回顾（狂神说java）

阳光穿透心脏的1/2处 2023-10-04 22:27 58阅读 0赞

#### 文章目录 ####

*  Spring学习笔记
 *   *  1.Spring
     *   *  1.1简介
         *  1.2.组成
         *  1.3优点
     *  2.IOC
     *   *  IOC本质
     *  3.Hello World
     *  4.IOC创建对象
     *  5.Spring的配置
     *   *  5.1别名
         *  5.2配置bean
         *  5.3import合并文件
     *  6.依赖注入
     *   *  6.1 构造器注入
         *  6.2 \*\*\*Set方式注入\*\*\*···重点···
         *  6.3 bean的作用域
     *  7、自动装配方式（bean）
     *   *  7.1 测试
         *  7.2 ByName
         *  7.3 ByType
         *  7.4 使用注解实现
     *  8、注解开发
     *  9、Java方式配置Spring
     *  10、代理模式
     *   *  10.1 静态代理
         *  10.2 加深理解
         *  10.3 动态代理
     *  11、AOP
     *   *  11.1AOP简介
         *  11.2 AOP在Spring中的作用
         *  11.3 使用Spring实现AOP
     *  12、声明式事务
     *   *  12.1 回顾事务
         *  12.2 Spring中的事务管理

## Spring学习笔记 ##

### 1.Spring ###

#### 1.1简介 ####

*  Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
 *  SSH：Struct2 + Spring + Hibernate!
 *  SSM：SpringMVC + Spring + Mybatis!
 *  官网：[https://spring.io/projects/spring-framework\#overview][https_spring.io_projects_spring-framework_overview]
 *  官方下载地址：[https://repo.spring.io/release/org/springframework/spring/][https_repo.spring.io_release_org_springframework_spring]
 *  GitHub：[https://github.com/spring-projects/spring-framework][https_github.com_spring-projects_spring-framework]
 *  pom依赖导入

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>

#### 1.2.组成 ####

![在这里插入图片描述][e3034edaee144217b2d241239826a72b.png]

#### 1.3优点 ####

● 非侵入式设计

Spring是一种非侵入式（non-invasive）框架，它可以使应用程序代码对框架的依赖最小化。  
● 方便解耦、简化开发

Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护工作都交给Spring容器管理，大大的降低了组件之间的耦合性。  
● 支持AOP

Spring提供了对AOP的支持，它允许将一些通用任务，如安全、事务、日志等进行集中式处理，从而提高了程序的复用性。  
● 支持声明式事务处理

只需要通过配置就可以完成对事务的管理，而无需手动编程。  
● 方便程序的测试

Spring提供了对Junit4的支持，可以通过注解方便的测试Spring程序。  
● 降低Java EE API的使用难度

Spring对Java EE开发中非常难用的一些API（如：JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

Spirng的两大特点

*  ***控制反转（IOC），面向切面编程（AOP）***

### 2.IOC ###

1.UserDao 接口

public interface UserDao {
        
        void getUser();
    }

2.UserDaoImpl 实现类

public class UserDaoImpl implements UserDao {
        
        public void getUser() {
        
            System.out.println("默认获取用户数据");
        }
    }

3.UserService 业务接口

public interface UserService {
        
        void getUser();
    }

4.UserServiceImpl 业务实现类

public class UserServiceImpl implements UserService {
        
    
        private UserDao userDao = new UserDaoImpl();
    
        public void getUser() {
        
            userDao.getUser();
        }
    }

5.测试

public class MyTest {
        
        public static void main(String[] args) {
        
    
            //用户实际调用的是业务层，dao层他们不需要接触！
            UserService userService = new UserServiceImpl();
            userService.getUser();
        }
    }

![在这里插入图片描述][12522c4378c7436a961be4cdc7a87f10.png]  
这里使用set注入，使原来程序的主动权由程序员改变成了用户。用户想调用什么就调用什么方法，极大程度的减少了程序员修改代码的压力。

private UserDao userDao;
    
        //利用set进行动态实现值的注入！
        public void setUserDao(UserDao userDao) {
        
            this.userDao = userDao;
        }

#### IOC本质 ####

控制反转（IOC），是一种设计思想，DI依赖注入是实现IOC的一种方法。没有IOC，我们使用面向对象编程，对象的创建由程序也就是我们程序员自己控制，使用IOC之后，对象创建的主动权发生反转了。  
通过xml或者注解，去获取产生特定对象的方式，**在Spring中实现控制反转的是IOC容器，实现方式就是DI。**

### 3.Hello World ###

随便建一个maven项目

> 实体类

public class Hello {
        
        private String str;
    
        public String getStr() {
        
            return str;
        }
    
        public void setStr(String str) {
        
            this.str = str;
        }
    
        @Override
        public String toString() {
        
            return "Hello{" +
                    "str='" + str + '\'' +
                    '}';
        }
    }

> xml

<?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
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    
        
        <bean id="hello" class="com.kuang.pojo.Hello">
            <property name="str" value="Spring"/>
        </bean>
    </beans>

> 最后测试一下

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());
        }
    }

*  这个时候对象就是由spring容器创建的，其属性也是Spring设置的。  
    这个过程就是控制反转！

### 4.IOC创建对象 ###

**在xml或者其他配置文件被加载的那一刻，其实对象已经开始初始化了。**  
Spring默认创建对象是使用无参构造的方式创建的，当然我们也可以使用有参构造的方式来创建对象。  
1、下标赋值

<bean id="user" class="com.kuang.pojo.User">
        <constructor-arg index="0" value="狂神说Java"/>
    </bean>

2、类型（不推荐）

<bean id="user" class="com.kuang.pojo.User">
        <constructor-arg type="java.lang.String" value="lifa"/>
    </bean>

3、参数名

<bean id="user" class="com.kuang.pojo.User">
        <constructor-arg name="name" value="李发"/>
    </bean>

### 5.Spring的配置 ###

#### 5.1别名 ####

如果添加了别名，我们也可以使用别名获取到这个对象。

为了使代码更加的简洁或减轻代码量。

#### 5.2配置bean ####

*  id：bean的唯一标识符，也就是相当于我们的对象名
 *  class：bean对象所对应的全限定名：包名+类名
 *  name：也是别名，而且name可以同时取多个别名

#### 5.3import合并文件 ####

一般用于团队开发使用，它可以将多个配置文件，导入合并为一个。  
张三开发一个xml，李四开发一个xml，王五开发一个xml，最后创建一个application.xml 使用import导入，合并为一个xml。  
这里就不写代码了，理解一下就可以。

### 6.依赖注入 ###

#### 6.1 构造器注入 ####

无参构造（spring默认）和有参构造，前面说过，这里不再赘述。

#### 6.2 ***Set方式注入***···重点··· ####

*  依赖注入：Set注入
 *  对象的所有属性值均由spring容器来注入！  
    【环境搭建】  
    1、复杂类型

public class Address {
        
        private String address;
    
        public String getAddress() {
        
            return address;
        }
    
        public void setAddress(String address) {
        
            this.address = address;
        }
    }

2、测试对象

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;
    }

3、beans.xml

<?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
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="student" class="com.kuang.pojo.Student">
            
            <property name="name" value="黑心白莲"/>
        </bean>
    </beans>

4、测试

public class MyTest {
        
        public static void main(String[] args) {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    
            Student student = (Student) context.getBean("student");
            System.out.println(student.getName());
        }
    }

5、最后完善信息

**p、c命名空间也是可以注入的**  
需要导入约束

xmlns:p="http://www.springframework.org/schema/p"
           xmlns:c="http://www.springframework.org/schema/c"

#### 6.3 bean的作用域 ####

*  单例模式（默认）

*  原型模式：每次从容器中get的时候，都会产生一个新对象！

### 7、自动装配方式（bean） ###

*  Spring会在上下文中自动寻找，并自动给bean装配属性！  
    1、在xml中显式的配置；  
    2、在java中显式配置；  
    3、**隐式的自动装配**bean\*\*

#### 7.1 测试 ####

创建新的模块，一个人 两个宠物！

#### 7.2 ByName ####

*  byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！

#### 7.3 ByType ####

*  byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！

注意：

*  ByName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
 *  ByType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

#### 7.4 使用注解实现 ####

Spring2.5版本以上支持注解，jdk1.5以上支持注解！  
1、导入约束  
2、配置注解的支持

**@Autowired**  
直接在属性上使用即可！也可以在set方法上使用！

> 测试

public class People {
        
        //如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
        @Autowired(required = false)
        private Cat cat;
        @Autowired
        private Dog dog;
        private String name;
    }

当自动装配无法完成的时候，使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入！

public class People {
        
        @Autowired
        @Qualifier(value = "cat111")
        private Cat cat;
        @Autowired
        @Qualifier(value = "dog222")
        private Dog dog;
        private String name;
    }

@Resource

public class People {
        
    
        @Resource
        private Cat cat;
    
        @Resource
        private Dog dog;
    }

***@Resource和@Autowired的区别：***

*  都是用来自动装配的，都可以放在属性字段上
 *  @Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】
 *  @Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
 *  执行顺序不同：@Autowired通过byType的方式实现。

### 8、注解开发 ###

在Spring4之后，基本上都要使用到注解开发。  
使用注解需要导入约束，配置注解的支持！

bean属性如何注入

//等价于<bean id="user" class="com.kuang.pojo.User"/>
    //@Component 组件
    
    @Component
    public class User {
        
    
        //相当于  <property name="name" value="白莲"/>
        @Value("白莲")
        public String name;
    }

衍生注解

*  @Component
 *  dao 【@Repository】
 *  service 【@Service】
 *  controller 【@Controller】  
    ***功能一样，将某个类注册到Spring中，装配bean***  
    自动装配
 *  @Autowired：自动装配通过类型，名字。如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = “xxx”)去配置。
 *  @Nullable 字段标记了了这个注解，说明这个字段可以为null;
 *  @Resource：自动装配通过名字，类型。  
    *xml与注解的区别*  
    xml用来管理bean；  
    注解只负责完成属性的注入；  
    xml更加万能，适用于任何场合！维护简单方便  
    如果让注解生效，就需要开启注解的支持！

<context:component-scan base-package="com.kuang"/>
        
        <context:annotation-config/>

### 9、Java方式配置Spring ###

从现在开始就不使用Spring的xml配置，都交给java来做！

> 实体类

//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
    @Component
    public class User {
        
        private String name;
    
        public String getName() {
        
            return name;
        }
    
        @Value("黑心白莲") //属性注入值
        public void setName(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "User{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

> 配置文件

// 这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Component
    // @Configuration代表这是一个配置类，就和我们之前看的beans.xml
    @Configuration
    @ComponentScan("com.kuang.pojo")
    @Import(KuangConfig2.class)
    public class KuangConfig {
        
    
        // 注册一个bean，就相当于我们之前写的一个bean标签
        // 这个方法的名字，就相当于bean标签中id属性
        // 这个方法的返回值，就相当于bean标签中的class属性
        @Bean
        public User user(){
        
            return new User(); // 就是返回要注入到bean的对象！
        }
    }

> 测试

public class MyTest {
        
        public static void main(String[] args) {
        
    
            //如果完全使用了配置类方式去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载！
            ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);
    
            User user = context.getBean("user", User.class);
            System.out.println(user.getName());
        }
    }

这种方式在springboot里面经常用到！

### 10、代理模式 ###

代理模式就是aop的底层原理！  
![在这里插入图片描述][c9ee4f3a6ae04651b965cf6b614b0d80.png]

#### 10.1 静态代理 ####

*  抽象角色：一般会使用接口或者抽象类来解决
 *  真实角色：被代理的角色
 *  代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
 *  客户：访问代理对象的人！  
    **抽象角色**

//租房
    public interface Rent {
        
        public void rent();
    }

**真实角色**

//房东
    public class Host implements Rent{
        
        public void rent() {
        
            System.out.println("房东出租房子！");
        }
    }

**代理角色**

public class Proxy implements Rent{
        
        private Host host;
    
        public Proxy() {
        
        }
    
        public Proxy(Host host) {
        
            this.host = host;
        }
    
        public void rent() {
        
            host.rent();
            seeHouse();
            sign();
            fee();
        }
    
        //看房
        public void seeHouse(){
        
            System.out.println("中介带着看房子！");
        }
    
        //签合同
        public void sign(){
        
            System.out.println("和中介签署租赁合同！");
        }
    
        //收费用
        public void fee(){
        
            System.out.println("中介收取费用！");
        }
    }

**客户端访问代理角色**

public class Client {
        
        public static void main(String[] args) {
        
            //房东要出租房子
            Host host = new Host();
    //        host.rent();
    
            //代理，中介帮房东出租房子，并且代理角色一般会有一些附属操作！
            Proxy proxy = new Proxy(host);
    
            //不用面对房东，直接找中介租房即可！
            proxy.rent();
        }
    }

*  可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
 *  公共角色就交给代理角色！实现了业务的分工！
 *  公共业务发生扩展的时候，方便集中管理！  
    不过代码量就会翻倍，开发效率会变低！

#### 10.2 加深理解 ####

**抽象角色**

public interface UserService {
        
        public void add();
        public void delete();
        public void update();
        public void query();
    }

**真实角色**

//真实角色
    public class UserServiceImpl implements UserService{
        
        public void add() {
        
            System.out.println("增加了一个用户！");
        }
    
        public void delete() {
        
            System.out.println("删除了一个用户！");
        }
    
        public void update() {
        
            System.out.println("修改了一个用户！");
        }
    
        public void query() {
        
            System.out.println("查询了一个用户！");
        }
    }

**代理角色**

public class UserServiceProxy implements UserService{
        
        private UserServiceImpl userService;
    
        public void setUserService(UserServiceImpl userService) {
        
            this.userService = userService;
        }
    
        public void add() {
        
            log("add");
            userService.add();
        }
    
        public void delete() {
        
            log("delete");
            userService.delete();
        }
    
        public void update() {
        
            log("update");
            userService.update();
        }
    
        public void query() {
        
            log("query");
            userService.query();
        }
    
        public void log(String msg){
        
            System.out.println("[Debug] 使用了一个"+msg+"方法");
        }
    }

**客户端访问代理角色**

public class Client {
        
        public static void main(String[] args) {
        
            UserServiceImpl userService = new UserServiceImpl();
    
            UserServiceProxy proxy = new UserServiceProxy();
            proxy.setUserService(userService);
    
            proxy.delete();
        }
    }

#### 10.3 动态代理 ####

*  其代理类是动态生成的
 *  其可以分成两个类：  
    1、基于接口 --JDK动态代理  
    2、基于类：cglib  
    3、java字节码实现：javassist  
    这里提前了解一下代理类（Proxy）；调用处理程序（invocationHandler）  
    **抽象角色**

public interface Rent {
        
        public void rent();
    }

\*\*真实角色

public class Host implements Rent{
        
        public void rent() {
        
            System.out.println("房东要出租房子！");
        }
    }

**ProxyInvocationHandler类**

//我们会用这个类，自动生成代理类！
    public class ProxyInvocationHandler implements InvocationHandler {
        
        //被代理的接口
        private Rent rent;
    
        public void setRent(Rent rent) {
        
            this.rent = rent;
        }
    
        //生成得到代理类
        public Object getProxy(){
        
            return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                    rent.getClass().getInterfaces(),this);
        }
    
        //处理代理实例，并返回结果
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            //动态代理的本质，就是使用反射机制实现！
            Object result = method.invoke(rent, args);
            seeHose();
            fee();
            return result;
        }
    
        public void seeHose(){
        
            System.out.println("中介带着看房子！");
        }
    
        public void fee(){
        
            System.out.println("中介收取费用！");
        }
    }

**测试**

public class Client {
        
        public static void main(String[] args) {
        
            //真实角色
            Host host = new Host();
    
            //代理角色：现在没有
            ProxyInvocationHandler pih = new ProxyInvocationHandler();
    
            //通过调用程序处理角色来处理我们要调用的接口对象！
            pih.setRent(host);
            Rent proxy = (Rent) pih.getProxy(); //这里的proxy就是动态生成的，我们并没有写
            proxy.rent();
    
        }
    }

**把ProxyInvocationHandler提出来作为工具类**

//用这个类自动生成代理类！
    public class ProxyInvocationHandler implements InvocationHandler {
        
    
        //被代理的接口
        private Object target;
    
        public void setTarget(Object target) {
        
            this.target = target;
        }
    
        //生成得到代理类
        public Object getProxy(){
        
            return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),this);
        }
    
        //处理代理实例，并返回结果
        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("[Debug] 使用了一个"+msg+"方法");
        }
    }

动态代理的好处：

*  可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
 *  公共角色就交给代理角色！实现了业务的分工！
 *  公共业务发生扩展的时候，方便集中管理！
 *  一个动态代理类代理的是一个接口，一般就是对应的一类业务
 *  一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

### 11、AOP ###

#### 11.1AOP简介 ####

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。  
![在这里插入图片描述][82f10aa1015e4a74b206b3ba3b9ab63a.png]

#### 11.2 AOP在Spring中的作用 ####

提供声明式事务；允许用户自定义切面

*  横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
 *  切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
 *  通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
 *  目标（Target）：被通知对象。
 *  代理（Proxy）：向目标对象应用通知之后创建的对象。
 *  切入点（PointCut）：切面通知执行的“地点”的定义。
 *  连接点（JointPoint）：与切入点匹配的执行点。  
    ![在这里插入图片描述][9f94980ef0a84d8d82a0bf3363e1bbc6.png]  
    Spring中支持5种类型的Advice：  
    ![在这里插入图片描述][4d6ff4313a04457aad812bf9a6ede491.png]  
    aop是在不改变原有代码的情况下，去增加新的功能。

#### 11.3 使用Spring实现AOP ####

使用AOP织入，需要导入一个依赖包！

<dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>

一、使用Spring的API接口【主要是SpringAPI接口实现】  
在service包下，定义UserService业务接口和UserServiceImpl实现类

public interface UserService {
        
        public void add();
        public void delete();
        public void update();
        public void select();
    }

public class UserServiceImpl implements UserService {
        
        public void add() {
        
            System.out.println("增加了一个用户！");
        }
    
        public void delete() {
        
            System.out.println("删除了一个用户！");
        }
    
        public void update() {
        
            System.out.println("更新了一个用户！");
        }
    
        public void select() {
        
            System.out.println("查询了一个用户！");
        }
    }

在log包下，定义我们的增强类，一个Log前置增强和一个AfterLog后置增强类

public class Log implements MethodBeforeAdvice {
        
    
        //method: 要执行的目标对象的方法
        //args：参数
        //target：目标对象
        public void before(Method method, Object[] agrs, Object target) throws Throwable {
        
            System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
        }
    }

public class AfterLog implements AfterReturningAdvice {
        
    
        //returnValue： 返回值
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        
            System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
        }
    }

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.xml文件

<?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
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop
            https://www.springframework.org/schema/aop/spring-aop.xsd">
    
        
        <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
        <bean id="log" class="com.kuang.log.Log"/>
        <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    
        
        
        <aop:config>
            
            <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
    
            
            <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
            <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
        </aop:config>
    
    </beans>

测试

public class MyTest {
        
        public static void main(String[] args) {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            //动态代理代理的是接口：注意点
            UserService userService = (UserService) context.getBean("userService");
    
            userService.add();
    //        userService.select();
        }
    }

二、自定义类来实现AOP【主要是切面定义】  
在diy包下定义自己的DiyPointCut切入类

public class DiyPointCut {
        
        public void before(){
        
            System.out.println("======方法执行前======");
        }
    
        public void after(){
        
            System.out.println("======方法执行后======");
        }
    }

配置文件

<bean id="diy" class="com.kuang.diy.DiyPointCut"/>
    
        <aop:config>
            
            <aop:aspect ref="diy">
                
                <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
                
                <aop:before method="before" pointcut-ref="point"/>
                <aop:after method="after" pointcut-ref="point"/>
            </aop:aspect>
        </aop:config>

三、使用注解实现！  
在diy包下定义注解实现的AnnotationPointCut增强类

//声明式事务！
    @Aspect //标注这个类是一个切面
    public class AnnotationPointCut {
        
    
        @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
        public void before(){
        
            System.out.println("====方法执行前====");
        }
    
        @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
        public void after(){
        
            System.out.println("====方法执行后====");
        }
    
        //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点；
        @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
        public void around(ProceedingJoinPoint jp) throws Throwable{
        
            System.out.println("环绕前");
    
            Signature signature = jp.getSignature();// 获得签名
            System.out.println("signature:"+signature);
    
            Object proceed = jp.proceed(); //执行方法
    
            System.out.println("环绕后");
    
            System.out.println(proceed);
        }
    
    }

在Spring配置文件中，注册bean，并增加支持注解的配置。

<bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
        
        <aop:aspectj-autoproxy/>

### 12、声明式事务 ###

#### 12.1 回顾事务 ####

*  把一组业务当成一个业务来做；要么都成功，要么都失败！
 *  事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
 *  确保完整性和一致性。  
    事务ACID原则：
 *  原子性（atomicity）
    
        事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。
 *  一致性（consistency）
    
        一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
 *  隔离性（isolation）
    
        可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
 *  持久性（durability）
    
        事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中。

测试：

将上面的代码拷贝到一个新项目中  
在之前的案例中，我们给userMapper接口新增两个方法，删除和增加用户；  
将上面的代码拷贝到一个新项目中  
在之前的案例中，我们给userMapper接口新增两个方法，删除和增加用户；

//添加一个用户
    int addUser(User user);
    
    //根据id删除用户
    int deleteUser(int id);

UserMapper文件，我们故意把 deletes 写错，测试！

<insert id="addUser" parameterType="com.kuang.pojo.User">
    insert into user (id,name,pwd) values (#{
        id},#{
        name},#{
        pwd})
    </insert>
    
    <delete id="deleteUser" parameterType="int">
    deletes from user where id = #{
        id}
    </delete>

编写接口的UserMapperImpl实现类，在实现类中，我们去操作一波

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
        
    
    
        //增加一些操作
        public List<User> selectUser() {
        
            User user = new User(5, "小王", "185161");
            UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
            mapper.addUser(user);
            mapper.deleteUser(5);
    
            return mapper.selectUser();
        }
        
        //新增
        public int addUser(User user) {
        
            return getSqlSession().getMapper(UserMapper.class).addUser(user);
        }
    
        //删除
        public int deleteUser(int id) {
        
            return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
        }
    }

测试

@Test
        public void test(){
        
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
    
            for (User user : userMapper.selectUser()) {
        
                System.out.println(user);
            }
        }

报错：sql异常，delete写错了

结果 ：数据库结果显示插入成功！

没有进行事务的管理；我们想让他们都成功才成功，有一个失败，就都失败，我们就应该需要事务！

以前我们都需要自己手动管理事务，十分麻烦！

但是Spring给我们提供了事务管理，我们只需要配置即可；

#### 12.2 Spring中的事务管理 ####

***编程式事务管理***

*  将事务管理代码嵌到业务方法中来控制事务的提交和回滚
 *  缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码  
    ***声明式事务管理***
 *  一般情况下比编程式事务好用。
 *  将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
 *  将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。  
    **使用Spring管理事务，注意头文件的约束导入 : tx**

xmlns:tx="http://www.springframework.org/schema/tx"
    
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd">

**JDBC事务**

**配置好事务管理器后我们需要去配置事务的通知**

<tx:advice id="txAdvice" transaction-manager="transactionManager">
            
            
            <tx:attributes>
                <tx:method name="add" propagation="REQUIRED"/>
                <tx:method name="delete" propagation="REQUIRED"/>
                <tx:method name="update" propagation="REQUIRED"/>
                <tx:method name="query" read-only="true"/>
                <tx:method name="*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>

**spring事务传播特性：**  
事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

*  propagation\_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
 *  propagation\_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
 *  propagation\_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
 *  propagation\_required\_new：新建事务，如果当前存在事务，把当前事务挂起。
 *  propagation\_not\_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
 *  propagation\_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
 *  propagation\_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation\_required类似的操作。  
    Spring 默认的事务传播行为是 PROPAGATION\_REQUIRED，它适合于绝大多数的情况。  
    **配置AOP，导入aop的头文件**

<aop:config>
            <aop:pointcut id="txPointCut" expression="execution(* com.kuang.mapper.*.*(..))"/>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
        </aop:config>

**删掉刚才插入的数据，再次测试！**

为什么需要事务？

*  如果不配置事务，可能存在数据提交不一致的情况；
 *  如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
 *  事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！  
    ***狂神老师的视频真的是非常适合大众学习，在边看边学的过程中收获颇多。让我们一起跟着狂神老师的视频加油吧！程序猿！***

[https_spring.io_projects_spring-framework_overview]: https://spring.io/projects/spring-framework#overview
[https_repo.spring.io_release_org_springframework_spring]: https://repo.spring.io/release/org/springframework/spring/
[https_github.com_spring-projects_spring-framework]: https://github.com/spring-projects/spring-framework
[e3034edaee144217b2d241239826a72b.png]: https://img-blog.csdnimg.cn/e3034edaee144217b2d241239826a72b.png
[12522c4378c7436a961be4cdc7a87f10.png]: https://img-blog.csdnimg.cn/12522c4378c7436a961be4cdc7a87f10.png
[c9ee4f3a6ae04651b965cf6b614b0d80.png]: https://img-blog.csdnimg.cn/c9ee4f3a6ae04651b965cf6b614b0d80.png
[82f10aa1015e4a74b206b3ba3b9ab63a.png]: https://img-blog.csdnimg.cn/82f10aa1015e4a74b206b3ba3b9ab63a.png
[9f94980ef0a84d8d82a0bf3363e1bbc6.png]: https://img-blog.csdnimg.cn/9f94980ef0a84d8d82a0bf3363e1bbc6.png
[4d6ff4313a04457aad812bf9a6ede491.png]: https://img-blog.csdnimg.cn/4d6ff4313a04457aad812bf9a6ede491.png