Spring5再学习笔记

学习来源bi站视频。

  1. Spring概念

  2. IOC容器

  3. Aop

  4. JDBCTemplate

  5. 事务管理

#### 1.Spring概述：

Spring是一个轻量级开源J2EE框架，Spring的核心IOC、Aop

IOC：翻转控制，把创建对象的过程交给Spring管理，不使用new关键字

Aop：面向切面编程，不修改源代码的情况进行功能的增强。

Spring特点：方便解耦，简化开发；切面分层，功能增强；方便测试；方便集成其他框架；降低Java API的操作，事务操作。

Spring分层

Spring框架最少对应四个包Beans、Core、 Context、 Expression和通用日志包common-log(apache项目)，在IEDA中配置项目import jar包，就可以在项目中直接导入这些包使用Spring框架进行操作，首先创建一个普通的类

package com.company;

public class User {
    public void add() {
        System.out.println("add……");
    }
}

Spring提供了不使用new进行实例化，通过Spring上下文进行类的获取，首先应当配置类，可以创建Spring配置文件或者以注解的方式实例化一个类

  1. Spring配置是采用XML进行配置的，比较固定的写法

    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 http://www.springframework.org/schema/beans/spring-beans.xsd"> <!--配置User对象创建--> <bean id="user" class="com.company.User"></bean> </beans>

  2. 测试代码编写，需要引入Junit类，直接使用IDEA引入就可以了

    ```java package com.company.testdemo;

    import com.company.User; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;

    public class TestSpring5 {

    @Test
public void testAdd() {

    // 1. 加载Spring配置文件 ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); // 2. 获取配置创建的对象 User user = context.getBean("user", User.class); user.add(); } }

    ```

  3. 运行，得到结果。

    Java运行结果

2.IOC容器

  1. IOC容器底层原理

  2. IOC接口（BeanFactory）

  3. IOC操作Bean（XML）

  4. IOC操作Bean（注解）

    1. IOC概念和原理

    控制翻转，是一种面向对象的设计原则，把对象的创建和对象之间的调用过程，交给Spring进行操作，使得耦合度降低。

    1. XML解析、工厂模式、反射

    解决的问题是高耦合的情况，例如传统的new实例化对象，如果对象本身发生变化（位置、方法）则需要对所有操作执行方法的地方进行修改（new的所有地方）

传统高耦合度

使用工厂模式可以进行解耦（工厂中包含耦合，可以统一的修改和返回）

工厂模式进行解耦

IOC过程：

  1. XML配置文件，配置创建的对象<bean id="dao" class="com.company.UserDao"/></bean>
  2. 有service类和dao类，解析XML文件后，通过这个名称解析class得到目标的class对象需要强制转化，创建工厂类 创建对象
  3. 这样即使对象和项目代码发生了变化，但是工厂类中的代码依旧不受影响，只需要对配置文件进行修改，就可以调用新的类，进一步的降低了耦合度。

IOC的接口：

  1. IOC思想基于IOC容器完成，本身就是对象工厂

  2. Spring提供了IOC容器的两种实现方式

    1. BeanFactory（一般在Spring内部使用，不提供开发人员使用）

      1. 在加载配置文件时不会创建对象，在获取对象使用对象时才创建对象

    2. ApplicationContext（是BeanFactory的子接口，支持更多功能）

      1. 加载配置文件时直接创建对象

IOC操作Bean管理

  1. 什么是Bean管理（创建对象、注入属性（修改类中的属性内容））

  2. Bean管理的操作实现（基于XML配置文件实现、基于注解方式实现）

  3. 在spring配置中，使用bean标签，可以在标签中添加对应属性，可以实现对象创建
  4. 在bean标签中有很多属性
    1. id：别名（唯一标识）
    2. class：包+类名（全路径）
    3. name：别名（可以使用特殊符号）

  5. 依旧会自动执行构造方法（默认执行默认无参数构造完成对象创建）

    1. 修改XML文件，需要注意使用constructor-arg标签而不是property基于XML方式注入属性

  7. DI：依赖注入，就是注入属性，需要在有对象的时候进行注入

    1. 传统注入方式

    ```java package com.company;

     public class Book {
     private String bName;

     //    set方式注入
     public void setBName(String bName) {
         this.bName = bName;
     }

     // 有参构造进行注入
     public Book(String bname) {
         this.bName = bname;
     }

     public static void main(String[] args) {

     }
 }

    ```

    1. 使用set方式进行注入

      1. 定义属性和对应set方法

      ```java package com.company;

      public class Book {
    private String bName;

    //    set方式注入
    public void setBName(String bName) {
        this.bName = bName;
    }
    public String getBName() {
     return this.bName;
  }

      }

      ```

      1. 在XML中进行注入 xml <!-- set方法注入属性--> <bean id="book" class="com.company.Book"> <!-- 在Bean标签中使用property进行属性的注入 name:名称，value值 --> <property name="BName" value="随便"></property> </bean>
      2. 测试代码

      ```java @Test public void testBook() { ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); Book book = context.getBean("book", Book.class); System.out.println(book.getBName());

          }

      ```

    2. 使用有参构造方法注入

      1. 首先创建具有构造方法的对象 ```java package com.company; public class Order { private String oname; private String address; // 参数构造 public Order(String oname, String address) { this.oname = oname; this.address = address; }

      public void getText() { System.out.println(this.oname + this.address); } } ```

      1. 修改XML文件，需要注意使用constructor-arg标签而不是property

      xml <!-- 有参构造创建属性--> <bean id="order" class="com.company.Order"> <constructor-arg name="address" value="测试"></constructor-arg> <constructor-arg name="oname" value="名字"></constructor-arg> </bean>

  8. 可以使用p名称空间注入，简化配置注入方式修改XML文件，首先增加xmlns:p做名称空间(底层还是set方法注入)

    xml <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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="book" class="com.company.Book" p:BName="随便"> </bean>

IOC操作Bean管理（XML注入其他类型方式）
  1. 字变量

可以设置为null

xml <bean id="book" class="com.company.Book"> <property name="BName"> <null> </null> </property> </bean>

可以设置为特殊符号(需要进行转义或者CDATA)

xml <bean id="book" class="com.company.Book"> <property name="BName"> <value><![CDATA[.;[].;.]]></value> </property> </bean>

  1. 外部bean

  2. （创建两个类）service、dao类

    ```java // dao interface package com.company.dao;

    public interface UserDao { void update(); }

    //dao impl package com.company.dao;

    public class UserDaoImpl implements UserDao { @Override public void update() { System.out.println("app update"); } }

    //service服务 package com.company.service;

    import com.company.dao.UserDao;

    public class UserService { private UserDao userDao;

      public void setUserDao(UserDao userDao) {
      this.userDao = userDao;
  }

  public void add() {
      System.out.println("test");
      this.userDao.update();

    // 创建对象(传统) // UserDao userDao=new UserDaoImpl();

      }

    }

    ```

  3. 在service中调用dao中的方法

    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 http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="userService" class="com.company.service.UserService"> <!-- 注入userdao对象,需要与其他bean对象的一致--> <property name="userDao" ref="userDaoImpl"></property> </bean> <bean id="userDaoImpl" class="com.company.dao.UserDaoImpl"></bean> </beans>

  4. 内部bean和级联赋值（可以用于数据库关系操作）

（1） 一对多关系：部门department类和员工staff类

```java package com.company.bean;

//部门类 public class Department { private String dName;

   public void setdName(String dName) {
       this.dName = dName;
   }

}

package com.company.bean;

// 员工类 public class Staff { private String sName; private String gender;

   private Department department;

   public void setDepartment(Department department) {
       this.department = department;
   }

   public void setGender(String gender) {
       this.gender = gender;
   }

   public void setsName(String sName) {
       this.sName = sName;
   }

} ```

配置XML

```xml

```

测试

java @Test public void testStaffBean(){ ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml"); Staff staff = context.getBean("staff", Staff.class); staff.printDepartment(); }

级联赋值，需要配置getter方法

```xml

```

如果是使用的集合类型，则使用下方的代码进行注入

xml <property name="XXX"> <array> <value>xxx</value> <value>xxxx</value> </array> </property> <property name="XXX"> <list> <value>xxx</value> <value>xxxx</value> </array> </property> <property name="XXX"> <map> <entry key="" value="">xxx</entry> </array> </property> <property name="XXX"> <set> <value>xxx</value> </array> </property>

如果是在集合中设置对象类型值，在集合中注入对象。

```xml 

   </bean>
   <!--    创建多个course对象-->
   <bean class="com.company.collection.Course" id="course1">
       <property name="cname" value="spring框架"></property>
   </bean>
   <bean class="com.company.collection.Course" id="course2">
       <property name="cname" value="mybatis"></property>
   </bean>

```

可以把集合注入部分提取出来，公共使用

在Spring配置文件中引入名称空间（xmlns:util，修改schemaLocation）

```xml

测试1 测试2 测试3 ```

##### IOC操作Bean管理

  1. Spring两种bean，普通bean和工厂bean（FactoryBean）

    1. 普通bean：在XML中定义的类型就是返回的类型
    2. 工厂bean：在配置文件定义的bean类型可以返回不同的类型

    ##### 工厂bean

    1、创建类，这个类作为工厂bean实现接口FactoryBean

    2、实现接口中的方法，在实现的方法中定义返回的bean类型

    ```java package com.company.factorybean;

    import com.company.collection.Course; import org.springframework.beans.factory.FactoryBean;

    public class MyBean implements FactoryBean {

      //    可以定义返回的bean类型
  @Override
  public Course getObject() throws Exception {
      Course course =new Course();
      course.setCname("abc");
      return course;
  }

  @Override
  public Class<?> getObjectType() {
      return null;
  }

  @Override
  public boolean isSingleton() {
      return false;
  }

    }

    ```

    在getObject中返回的类型就是MyBean这个对象通过context.getBean获取的内容。

    ```xml <?xml version="1.0" encoding="UTF-8"?> 

      <bean id="myBean" class="com.company.factorybean.MyBean"></bean>

    ```

    测试时需要注意返回内容

    java @Test public void testMyBean() { ApplicationContext context = new ClassPathXmlApplicationContext("bean7.xml"); Course myBean = context.getBean("myBean", Course.class); myBean.toString(); }

    #### Bean的作用域

    ​ 在默认情况下，bean都是单实例的，如下方代码；

    ```java @Test public void testMyBean2() { ApplicationContext context = new ClassPathXmlApplicationContext("bean7.xml"); Course myBean1 = context.getBean("myBean", Course.class); Course myBean2 = context.getBean("myBean", Course.class); //打印地址 System.out.println(myBean1); System.out.println(myBean2); }

    //这个是因为使用工厂bean @Override public boolean isSingleton() { return true; } ```

    如果是普通bean的话，就采用配置文件中的scope属性，值（singleton、prototype）

    xml <bean id="myBean" class="com.company.factorybean.MyBean" scope="prototype"></bean>

    当加载配置文件时，默认singleton会自动创建，new ClassPathXMLApplicationContext()，多实例时只有在使用时创建。

    #### Bean的生命周期

    （1）通过构造器创建bean实例（无参数构造）

    （2）为bean的属性设置值和对其他bean引用（调用set方法）

    （3）调用bean的初始化方法（需要进行配置bean对象的init-method）

    （4）bean可以使用了（对象获取到了）

    （5）当容器关闭时，调用bean的销毁方法（需要进行配置销毁方法destroy-method）

    如果使用了Bean的后置处理器，则有七步生命周期钩子方法

    （1）通过构造器创建bean实例（无参数构造）

    （2）为bean的属性设置值和对其他bean引用（调用set方法）

    （3）把bean实例传递bean后置处理器的方法（postProcessBeforeInitialization）

    （4）调用bean的初始化方法（需要进行配置bean对象的init-method）

    （5）把Bean实例传递Bean后置处理器的方法 （postProcessAfterInitialization）

    （6）bean可以使用了（对象获取到了）

    （7）当容器关闭时，调用bean的销毁方法（需要进行配置销毁方法destroy-method）

                                #### Bean的后置处理器

    1. 继承BeanPostProcessor实现其中提供的两个方法postProcessBeforeInitialization、postProcessAfterInitialization

      ```java package com.company.bean;

      import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.lang.Nullable;

      public class MyBeanPost implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("在初始化之后前的方法"); return bean; }

       @Override
 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
     System.out.println("在初始化之后执行的方法");
     return bean;
 }

      }

      ```

      原始bean

      ```java package com.company.bean;

      public class BeanLiftCycle { private String testText;

       public void setTestText(String testText) {
     System.out.println("2. 注入参数的值");
     this.testText = testText;
 }

 public BeanLiftCycle() {
     System.out.println("1. 构造方法");
 }

 public void useThisBean() {
     System.out.println("4.使用Bean对象");
 }

 void initMethod() {
     System.out.println("3.配置的初始化方法");
 }

 void destroyMethod() {
     System.out.println("5.配置的析构方法");
 }

      }

      ```

      配置XML

      ```xml <?xml version="1.0" encoding="UTF-8"?> 

       <bean id="myBean" class="com.company.bean.BeanLiftCycle" init-method="initMethod"
       destroy-method="destroyMethod">
     <property name="testText" value="测试"></property>
 </bean>

 <!--    配置后置处理器-->
 <bean id="myBeanPost" class="com.company.bean.MyBeanPost"></bean>

      ```

      测试代码中需要手动进行bean的销毁，可以使用ApplicationContext的子接口ClassPathXmlApplicationContext。

      java @Test public void testBeanLife(){ ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean8.xml"); BeanLiftCycle beanLiftCycle=context.getBean("myBean",BeanLiftCycle.class); beanLiftCycle.useThisBean(); context.close(); }

      运行结果

      Bean生命周期

Spring自动装配（IOC操作Bean管理，XML自动装配）

  1. 自动装配 根据规则属性名称或者类型，Spring将自动将匹配的属性值进行注入

```java package com.company.autowire;

public class Emp { private Dept dept;

public void setDept(Dept dept) {
    this.dept = dept;
}

@Override
public String toString() {
    return "Emp{" +
            "dept=" + dept +
            '}';
}

public void test() {
    System.out.println(dept);
}

}

```

自动装配配置autowire属性

<?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属性中有autowire，两个值byName和byType
    byName是名称和对应bean的id的值必须一致
    byType根据属性类型进行装配，如果出现多个相同的类型，会出现错误
    -->
    <bean id="emp" class="com.company.autowire.Emp" autowire="byType">
        <!--        <property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="com.company.autowire.Dept"> </bean>
</beans>

IOC bean管理XML方式，外部依赖数据（数据库德鲁伊连接池druid）

  1. 首先下载druid的jar包，导入工厂中

  2. 配置连接池，XML方式，注入bean

```xml 

   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

       <property name="driverClassName" value=""></property>
       <property name="url" value=""></property>
       <property name="username" value="root"></property>
       <property name="password" value="root"></property>
   </bean>

```

  1. 配置外部文件jdbc.properties

properties prop.driverClass=com.mysql.jdbc.Driver prop.url=jdbc:mysql://localhost:3306/spring-learn prop.username=root prop.password=root

  1. 在XML中引入名称空间context

```xml 

   <context:property-placeholder location="classpath:jdbc.properties"/>
   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
       <!--&lt;!&ndash;注入属性&ndash;&gt;-->
       <property name="driverClassName" value="${prop.driverClass}"></property>
       <property name="url" value="${prop.url}"></property>
       <property name="username" value="${prop.username}"></property>
       <property name="password" value="${prop.password}"></property>
   </bean>

```

注解方式的IOC操作（简化XML）

  1. Spring中的对象创建（注解功能一致，用来创建bean实例，可以混用）

  2. @Component

  3. @Service
  4. @Controller

  5. @Repository

  6. 项目中需要引入AOP包

  7. 开启组件的扫描，需要引入context域，可以扫描全包或者是不使用默认filter扫描（use-default-filter="false"）

```xml 

   <context:component-scan base-package="com.company"></context:component-scan>

```

  1. 开启后，可以是直接使用注解简化写法

```java package com.company.service;

import org.springframework.stereotype.Component; import org.springframework.stereotype.Service;

//@Component(value = "userService")//等同于XML中注册bean id=“userService” @Service public class UserService {

   public void add() {
       System.out.println("service add^");
   }

}

```

  1. 测试

java @Test public void test() { System.out.println("test"); ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); UserService userService = context.getBean("userService",UserService.class); userService.add(); }

#### 实现注解方式进行属性注入

@Autowired：根据属性类型进行自动装配

  1. 对service、dao对象进行创建，需要在service和dao的实现类中增加注解(需要开启注解扫描器)

    ```java package com.company.service;

    import com.company.dao.UserDao; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.springframework.stereotype.Service;

    //@Component(value = "userService")//等同于XML中注册bean id=“userService” @Service public class UserService { @Autowired private UserDao userDao;

      public void add() {
      System.out.println("service add^");
      userDao.add();
  }

    }

    ```

    ```java package com.company.dao;

    public interface UserDao { public void add(); }

    package com.company.dao;

    import org.springframework.stereotype.Repository;

    @Repository public class UserDaoImpl implements UserDao { @Override public void add() { System.out.println("add"); } } ```

​ @Quakifier：根据属性名称进行装配（多个实现类时），需要和@Autowired一起使用

​ @Resource：根据类型或者名称注入（是Javax中的注解，不是Spring中的注解）

​ @Value：注入普通类型（例如字符串配置）

​

完全注解开发

通过配置类来完成XML的工作。

新建一个config包，新建一个SpringConfig类

package com.company.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = {"com.company"})
public class SpringConfig {

}

在测试方法中第一步通过XML获取配置需要进行修改，从配置类中获取到context对象。

    @Test
    public void test2(){
//        加载配置类
        ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService",UserService.class);
        userService.add();
    }

Spring 中的AOP

面向切面编程，降低耦合度。

AOP的概念

  1. AOP采用的动态代理方式实现

（1）两种情况

  1. 有接口的情况

    将会使用JDK动态代理

    创建接口实现类的代理对象，实现对象增强

  2. 没有接口的情况

    使用CGLIB动态代理

    创建子类的代理对象，增强方法功能

  3. 代码实现

使用Proxy类实现对象 java.lang.proxy，调用newProxyInstance(ClassLoader loader, 类<?>[] interfaces,InvocationHandler h)类加载器、增强方法所使用的类接口（可以多个）、实现接口增强的代理对象。

首先建立一个基本的接口和实现类。

```java package com.company;

public interface UserDao { public int add(int a, int b);

   public String update(String id);

}

package com.company;

public class UserDaoImpl implements UserDao { @Override public int add(int a, int b) { return a + b; }

   @Override
   public String update(String id) {
       return id;
   }

} ```

在这这个实现类基础上进行功能增强，可以使用匿名内部类的形式，或者是具名类的方式

```java package com.company;

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;

public class JDKProxy { public static void main(String[] args) { // 创建接口实现类的代理 Class[] interfaces = {UserDao.class}; UserDaoImpl userDao = new UserDaoImpl(); UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao)); int result = dao.add(1, 2); System.out.println("测试结束" + result); // Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() { //// 匿名内部类方式 // @Override // public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // return null; // } // }) } }

// 创建代理单独类 class UserDaoProxy implements InvocationHandler { // 1.把创建的是谁的代理对象，把谁传递过来 private Object obj;

   //    有参构造方式传递
   public UserDaoProxy(Object obj) {
       this.obj = obj;
   }

   //    增强的逻辑
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

// 方法之前执行 System.out.println("之前执行" + method.getName()); // 执行方法 Object res = method.invoke(obj, args); // 方法之后执行 System.out.println("方法之后执行" + obj);

       return res;
   }

}

```

#### AOP术语

  1. 连接点

    类中那些方法可以被增强，就被称为连接点

  2. 切入点

    实际上增强的方法被称为切入点

  3. 通知（增强）

    实际增强的部分被称为通知，通知有多重类型（前置通知、后置通知、环绕通知、异常通知、最终通知）

  4. 切面

    是一个动作，把通知应用到切入点的过程被称为切面

#### AOP操作

  1. 在Spring中经常使用AspectJ实现AOP操作，AspectJ可以直接实现AOP操作，不是Spring组成部分，但是经常一起使用

  2. 引入AspectJ依赖

spring-aspects-5.2.6.RELEASE.jar/aspectweaver啥的，直接使用pom安装了,包括之后要用到的包。

xml <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.8.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>5.2.8.RELEASE</version> </dependency> <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter</artifactId> <version>RELEASE</version> <scope>compile</scope> </dependency> </dependencies>

  1. 切入点表达式

execution([权限修饰符][返回类型][类全路径][方法名称][参数列表])

execution(* com.company.*.*,……)

  1. AOP操作（注解）

  2. 创建一个类，定义方法

    ```java package aoptest;

    import org.springframework.stereotype.Component;

    @Component public class User { public void add() { System.out.println("执行add"); } }

    ```

  3. 编写增强的逻辑

    ```java package aoptest;

    import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component;

    @Component @Aspect public class UserProxy { // 环绕通知 @Around(value = "execution(* aoptest.User.add(..))") public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { System.out.println("环绕之前"); // 被增强的方法执行 proceedingJoinPoint.proceed(); System.out.println("环绕之后"); }

      //    前置通知
  @Before(value = "execution(* aoptest.User.add(..))")
  public void before() {
      System.out.println("在before中执行");
  }

  //    最终执行，出现异常依旧执行
  @After(value = "execution(* aoptest.User.add(..))")
  public void after() {
      System.out.println("在after中执行");
  }

  //异常出现时执行
  @AfterThrowing(value = "execution(* aoptest.User.add(..))")
  public void afterEx() {
      System.out.println("在after中出现错误");
  }

  //    后置通知，只有正常返回后才执行
  @AfterReturning(value = "execution(* aoptest.User.add(..))")
  public void afterFinish() {
      System.out.println("最终都会执行");
  }

    } ```

  4. 在Spring配置文件中，开启注解扫描，需要使用context空间，aop空间

    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:context="http://www.springframework.org/schema/context" 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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd "> <!--开启注解扫描--> <context:component-scan base-package="aoptest"></context:component-scan> <!-- 开启Aspect生成代理对象--> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>

  5. 使用注解创建User和UserProxy对象

    如上面代码所示

  6. 在增强类上面添加注解@Aspect

    如上面代码所示

  7. 在配置类中开启生成代理对象

    如上面XML配置

  8. 配置不同类型的通知，在增强类中，使用注解方式添加切入点表达式

    如上面代码所示

  9. 运行

    ```java package test;

    import aoptest.User; import org.junit.jupiter.api.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;

    public class test {

      @Test
  public void testAop() {
      ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
      User user = context.getBean("user", User.class);
      user.add();
  }

    }

    ```

    运行结果

    • 重用切入点

    ```java // 重用切入点，切入点定义 @Pointcut(value = "execution(* aoptest.User.add(..))" ) public void pointdemo() { // 这个不会执行 System.out.println("使用公共切入点"); }

      //    环绕通知
  @Around(value = "pointdemo()")
  public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
      System.out.println("环绕之前");

    // 被增强的方法执行 proceedingJoinPoint.proceed(); System.out.println("环绕之后"); }

      //    前置通知
  @Before(value = "pointdemo()")
  public void before() {
      System.out.println("在before中执行");
  }

    ```

    • 多个增强类对同一个类进行增强，使用@Order注解控制优先级，数字越小越优先（0开始）

      ```java package aoptest;

      import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.core.annotation.Order; import org.springframework.stereotype.Component;

      @Component @Aspect @Order(2)//这个东西是执行的优先级 public class PersonProxy { @Before(value = "execution(* aoptest.User.add(..))") public void before() { System.out.println("Person before第二个增强类"); } }

      ```

  10. AOP操作（XML）

XML中应当包含bean的注入和AOP的配置

```xml

```

  • 可以直接使用配置类开启AOP切面

    ```java package config;

    import aoptest.User; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.EnableAspectJAutoProxy;

    @Configuration @ComponentScan(basePackages = {"aoptest"}) //注解开启切面 @EnableAspectJAutoProxy public class SpringConfig { public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class); User user = context.getBean("user", User.class); user.add(); } }

    ```

    注解开启AOP

链接