spring

Spring框架概述

Spring 框架是一个分层的、面向切面的 Java 应用程序的一站式轻量级解决方案，它是 Spring 技术栈的核心和基础，是为了解决企业级应用开发的复杂性而创建的。简言之：使现有技术更加容易使用，并对其他的开源框架的使用提供支持。如：SSH（全自动框架）SSM（半自动）框架都以spring为中心进行整合。

使用需要的依赖

     <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.21</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.21</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.21</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.21</version>
        </dependency>

IOC

控制反转概念

• 是面向对象编程的一种设计模式，把对象创建和对象之间的调用过程 交给spring进行管理
• 目的：降低耦合度

IOC底层原理 xml解析、工厂模式、反射

过程：

1. xml配置文件 配置创建的对象

   <bean id="dao" class="com.kk.UserDao></bean>
   

2. 创建工厂

   class UserFactory{
        public static UserDao getDao(){
            String classValue = class //通过xml解析获得
            Class clazz = Class.forName(classValue);//通创反射创建对象
            return (UserDao)clazz.newInstance();
        }
   }
   

IOC(接口)

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

spring提供IOC容器实现两种方式：(两个接口) 两者都能加载配置文件 获取配置创建对象

1. BeanFactory：IOC容器基本实现 是spring内部的使用接口 不提供开发人员进行使用 加载配置文件时不会创建 获取对象时才创建对象

2. ApplicationContext：BeanFactory接口的子接口 功能更加强大 一般由开发人员进行使用 在加载配置文件时就创建对象（较常用）

IOC操作Bean管理

管理的两种方式：xml方式、注解方式 管理形式：spring创建对象、spring注入属性

基于xml方式实现

创建对象： 创建对象时 默认执行无参构造方法完成对象创建

<bean id="user" class="com.kk.User"></bean>

注入属性： DI：依赖注入 常用方法注入 使用set、使用有参构造 1. 使用配置文件注入 默认调用set方法注入

    <bean id="user" class="com.kk.User">
        <property name="name" value="wlk"></property>
    </bean>

public class Test_ {
    public static void main(String[] args) {
        //1.加载spring配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取配置创建的对象
        User user = context.getBean("user", User.class);
        System.out.println(user.getName());
    }
}

1.2 p名称空间注入 本质上也是set方式注入 仅仅只是简化了上面的方法 前提：在配置文件头部导入 xmlns:p="http://www.springframework.org/schema/p"

<bean id="user" class="com.kk.User" p:name="wlk" p:age="19"></bean>

2. 使用有参构造进行注入 前提：需要存在有参构造器 使用constructor-arg标签表示使用有参构造器配置参数

    <bean id="user" class="com.kk.User">
        <constructor-arg name="name" value="wkk"/>
        <constructor-arg name="age" value="18"/>
    </bean>

小细节： 想要设置空值使用标签

    <bean id="user" class="com.kk.User">
        <property name="name"><null/></property>
    </bean>

不使用转意字符输出符号

    <bean id="user" class="com.kk.User">
        <property name="name">
            <value>
                <![CDATA[ <<<<<<符号>>>>>> ]]>
            </value>
        </property>
    </bean>

注入外部bean

使用情况：当创建对象时 内部需要创建外部的一个对象时

模拟情况

public class UserService {
    public void add(){
        System.out.println("service add...");
        //准备使用bean对该地方进行创建对象
        UserDao userDao = new UserDaoImpl();
        userDao.update();
    }
}

创建UserDao类型属性 生成set方法

创建一个bean 表示创建一个其他类(此处时UserDao)，在本类中的bean下设置property的ref为该bean的id表示在本类中创建一个其他类

    <bean id="userService" class="com.kk.service.UserService">
        <!--注入userDao对象-->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>

    <bean id="userDaoImpl" class="com.kk.dao.UserDaoImpl"></bean>

public class UserService {
    //创建UserDao类型属性 生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add...");
        userDao.update();
    }
    @Test
    public void test(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", this.getClass());

        userService.add();
    }
}

注入属性——内部bean和级联赋值

引入：数据库一对多关系 部门department 员工employment

bean对象

public class Department {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
    @Override
    public String toString() {
        return "Department{" +
                "dname='" + dname + '\'' +
                '}';
    }
}


public class Employee {
    private String eName;
    private String gender;
    private Department depart;
    public void seteName(String eName) {
        this.eName = eName;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public Department getDepart() {
        return depart;
    }
    public void setDepart(Department depart) {
        this.depart = depart;
    }
    public void test(){
        System.out.println(eName+"  "+gender+"   "+depart);
    }
}

xml配置

外部bean注入方式：

    <bean id="department" class="com.kk.bean.Department">
        <property name="dname" value="finance"/>
    </bean>
    <bean id="employee" class="com.kk.bean.Employee">
        <property name="eName" value="kk"/>
        <property name="gender" value="male"/>
        <property name="depart" ref="department"/>
    </bean>

内部bean注入方式：

    <bean id="employee" class="com.kk.bean.Employee">
        <property name="eName" value="kk"/>
        <property name="gender" value="male"/>
        <property name="depart">
            <bean id="department" class="com.kk.bean.Department">
                <property name="dname" value="finance"/>
            </bean>
        </property>
    </bean>

Test类

public class Test_ {
    public static void main(String[] args) {
        //1.加载spring配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取配置创建的对象
        Employee employee = context.getBean("employee", Employee.class);
        employee.test();
    }
}

注入属性-级联赋值 级联赋值在使用上，是在一个bean对象中注入另一个bean对象（外部bean）的属性并对该属性进行赋值。上面代码的外部赋值就是一种级联赋值

外部bean注入方式：

    <bean id="department" class="com.kk.bean.Department">
        <property name="dname" value="finance"/>
    </bean>
    <bean id="employee" class="com.kk.bean.Employee">
        <property name="eName" value="kk"/>
        <property name="gender" value="male"/>
        <property name="depart" ref="department"/>
    </bean>

内部bean注入方式：

    <bean id="employee" class="com.kk.bean.Employee">
        <property name="eName" value="kk"/>
        <property name="gender" value="male"/>
        <property name="depart">
            <bean id="department" class="com.kk.bean.Department">
                <property name="dname" value="finance"/>
            </bean>
        </property>
    </bean>

xml注入集合

常见集合：数组、Set、List、Map

创建bean类(Jihe)

public class Jihe {
    private String[] idNum;
    private List<String> name;
    private Map<String,String> course;
    private Set<String> grade;
    //该类之前创建过
    private List<Employee> employees;

    public void setEmployees(List<Employee> employees) {
        this.employees = employees;
    }

    public void setIdNum(String[] idNum) {
        this.idNum = idNum;
    }

    public void setName(List<String> name) {
        this.name = name;
    }

    public void setCourse(Map<String, String> course) {
        this.course = course;
    }

    public void setGrade(Set<String> grade) {
        this.grade = grade;
    }
    public void test(){
        System.out.println(Arrays.toString(idNum));
        System.out.println(name);
        System.out.println(course);
        System.out.println(grade);
        for (Employee employee : employees) {
            employee.test();
        }
    }
}

xml配置注入

    <bean id="jihe" class="com.kk.bean.Jihe">
        <property name="idNum">
            <array>
                <value>100321</value>
                <value>103421</value>
                <value>105421</value>
                <value>105421</value>
            </array>
        </property>
        <property name="name">
            <list>
                <value>name1</value>
                <value>name2</value>
                <value>name3</value>
            </list>
        </property>
        <property name="course">
            <map>
                <entry key="9001" value="Java"></entry>
                <entry key="9002" value="SQL"></entry>
                <entry key="9003" value="web"></entry>
            </map>
        </property>
        <property name="grade">
            <set>
                <value>99</value>
                <value>299</value>
                <value>919</value>
                <value>499</value>
                <value>499</value>
            </set>
        </property>
        <!--当集合内需要创建对象时 在外部配置好属性-->
        <property name="employees">
            <list>
                <ref bean="e1"></ref>
                <ref bean="e2"></ref>
            </list>
        </property>
    </bean>
    <bean id="e1" class="com.kk.bean.Employee">
        <property name="eName" value="k"></property>
    </bean>
    <bean id="e2" class="com.kk.bean.Employee">
        <property name="eName" value="kk"></property>
    </bean>

Test_测试

public class Test_ {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        Jihe demo=context.getBean("jihe", Jihe.class);
        demo.test();
    }
}

IOC操作Bean管理（FactoryBean）

Spring有两种类型bean 一种是普通bean 一种是工厂bean(FactoryBean)

普通bean：定义的类型就是返回的类型 工厂bean：定义的类型可以与返回值类型不同

工厂bean的实现方式 创建一个类，让这个类作为工厂bean，实现接口FactoryBean 实现接口里的方法 在实现的方法中定义返回的bean类型

创建一个工厂bean（.java文件）此时设置传入类型为User类

public class MyBean implements FactoryBean<User> {
    //返回实例
    public User getObject() throws Exception {
        Class<?> clazz = Class.forName("com.kk.User");
        Constructor constructor = clazz.getConstructor();
        User user = (User) constructor.newInstance();
        user.setAge(11);
        user.setName("kk");
        return user;
    }
    //返回类型
    public Class<?> getObjectType() {
        return null;
    }
    //判断是否为单例
    public boolean isSingleton() {
        return false;
    }
}

xml配置

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

Test_测试 可以通过MyBean接收的不同类型设置不同的接收类型

public class Test_ {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
//        User myBean = context.getBean("myBean", User.class);
        Object myBean = context.getBean("myBean", Object.class);
        System.out.println(myBean.getClass());
        System.out.println(myBean.toString());
    }
}

Bean作用域

在Spring里面，默认情况下，bean是单实例对象

public class Test_ {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        User u1 = context.getBean("myBean", User.class);
        User u2 = context.getBean("myBean", User.class);
        System.out.println(u1==u2);//true 说明每次创建都是同一个对象---单例
    }
}

设置 单实例/多实例 对象 通过创建bean时设置 scope 属性 prototype(多)/singleton(单)

<bean id="myBean" class="com.kk.User" scope="prototype"></bean>

<bean id="myBean" class="com.kk.User" scope="singleton"></bean>

注意： 当默认或者设置为单实例对象时，在加载spring配置文件时就创建了单实例对象 当设置为多实例时，加载配置文件不会创建对象，而是在调用getBean方法时创建对象

Bean生命周期

1. 通过构造器创建实例对象（无参构造）
2. 为bean的属性设置值和对其他bean引用（调用set方法）
3. 把bean实例传递bean后置处理的方法
4. 调用bean的初始化方法（需进行配置初始化的方法）
5. 把bean实例传递bean后置处理器的方法
6. bean可以使用了（对象获取到了）
7. 当容器关闭时，调用bean的销毁的方法（需进行配置销毁的方法）

实体类(Live)

public class Live {
    private String name;


    public Live() {
        System.out.println("1 "+"无参构造");
    }
    public void setName(String name) {
        this.name = name;
        System.out.println("2 "+"设置参数");
    }
    public void Init_method(){
        System.out.println("3 "+"初始化方法");
    }
    public void Destroy_method(){
        System.out.println("5 "+"销毁");
    }
}

xml配置文件

    <bean id="Live" class="com.kk.bean.Live" init-method="Init_method" destroy-method="Destroy_method">
        <property name="name" value="kk"/>
    </bean>

    <bean id="myBeanPost" class="com.kk.bean.MyBeanPost"></bean>

Test_测试类

public class Test_ {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        Live demo1=context.getBean("Live",Live.class);
        System.out.println("4 获取创建的bean对象");
        ((ClassPathXmlApplicationContext)context).close();
    }
}

XML自动装配

在配置xml中bean的里面设置autowire

1. 根据属性名称自动装配(byName)
2. 更具属性值自动装配(byType)

byName

<!--    byName 注入值bean的id和类属性名一样-->
    <bean id="employee" class="com.kk.bean.Employee" autowire="byName">
    <!--        <property name="depart" ref="department"/> 该方法为手动注入-->
    </bean>
    
    <bean id="depart" class="com.kk.bean.Department"><property name="dname" value="1"/> </bean>

byType

<!--    byType 通过类型自动输入 缺点：当同时创建两个class相同的类就会报错-->
    <bean id="employee" class="com.kk.bean.Employee" autowire="byType">
<!--        <property name="depart" ref="department"/> 该方法为手动注入-->
    </bean>
    
    <bean id="department" class="com.kk.bean.Department"><property name="dname" value="1"/> </bean>

引入外部的properties

前提： xml头部配置加入： xmlns:context="http://www.springframework.org/schema/context" 创建properties文件 存放配置信息

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
username=root
password=123456

把外部properties属性文件引入到spring配置文件中

​ 引入contex名称空间

<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/util http://www.springframework.org/schema/util/spring-util.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

xml配置属性

//将properties文件引入到xml当中
    <context:property-placeholder location="jdbc.properties"/>
//配置属性
    <bean id="druid" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driverClassName}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
    </bean>

Test_测试

public class Test_ {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        Object object = context.getBean("druid",Object.class);
        System.out.println(object);
    }
}

基于注解方式实现

什么是注解： 注解是代码特殊标记，格式：＠注解名称（属性名称＝属性值，属 性名称＝属性值） 使用注解,注解作用在类上面,方法上面,属性上面 目的：简化xml配置

spring针对Bean管理中创建对象提供注解 功能都是一样的

• @Component --all
• @Service --service层
• @Controller --controller层
• @Repository --dao层

使用注解方式创建对象

1. 引入依赖

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.3.21</version>
        </dependency>

xml设置头部

<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">

2. 开启组件扫描 在xml中引入组件扫描

<!--扫描多个包
        1. 使用逗号隔开
        2. 扫描包的上层目录-->
    <context:component-scan base-package="com.kk.dao,com.kk.service"></context:component-scan>

3. 创建类 在累的上面添加创建对象注解

//如果value不写，则默认值为该类首字母小写  UserService-->userService
@Component(value = "userService")//<bean id="userService" class="...">
public class UserService {
   public void add(){
        System.out.println("service add...");
    }
}

组件扫描配置（设置父包下哪些需要扫描

//示例1,需要扫描的内容
<context:component-scan base-package="com.kk.dao,com.kk.service" user-default-filter="false">
    <context:include-filter type="annotion" expression="org.springframework.stereotype.Controller" />
</context:component-scan>
//示例2,不需要扫描的内容
<context:component-scan base-package="com.kk.dao,com.kk.service" user-default-filter="false">
    <context:exclude-filter type="annotion" expression="org.springframework.stereotype.Controller" />
</context:component-scan>

注解实现属性注入

1. @Autowired:根据属性类型进行自动装配

@Service(value = "userService")
public class UserService {
    //不需要set方法 已经被封装了
    //添加注入注解
    @Autowired //类型注入(byType) 相当于创建了一个class=com.kk.dao.userDao的bean 然后注入到userService的bean的property当中(注入bean)
    public UserDao userDao;
    public void add(){
        System.out.println("service add...");
    }
}

@Repository
public class UserDaoImpl implements UserDao{

    public void dao() {
        System.out.println("dao dao...");
    }
}

2. @Qualifler:根据属性名称进行注入,和Autowired一起使用

   和byType一样如果使用@Autowired 当很多类实现Dao时该注解找不到 故要使用@Qualifler注解进行特指

@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao{

    public void dao() {
        System.out.println("dao dao...");
    }
}

//当id被改变之后可以是用@Qualifier(..)特定指向name为(..)的值

@Service(value = "userService")
public class UserService {
    //不需要set方法 已经被封装了
    //添加注入注解
    @Autowired
    @Qualifier("userDaoImpl1")
    public UserDao userDao;
    public void add(){
        System.out.println("service add...");
    }
}

3. @Resource:可以根据 类型注入,可以根据名称注入 使用@Resource(name="..")时按名称注入 使用@Resource时按类型注入 该注解是javax提供 import javax.annotation.Resource; 而上面两个注解 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; 不建议使用@Resource
4. @Value:注入普通类型属性 相当于 配置bean时给里面property填上value值

@Service(value = "userService")
public class UserService {

    @Value("kk")
    private String name;

    public void test(){
        System.out.println("name:"+name);
    }
}

public class Test_ {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.test();
    }
}

完全注解开发

1. 使用一个类去替代xml文件(此时xml当中就一个包扫描配置)

@Configuration//表明自己替代了xml配置文件
//包扫描
//@ComponentScan(basePackages = "com.kk")
@ComponentScans({@ComponentScan(basePackages = "com.kk.dao"),
        @ComponentScan(basePackages = "com.kk.service")})
public class SpringConfig {
}

2. 编写测试类 获取configuration返回的context

    @Test
    public void test2(){
        AnnotationConfigApplicationContext context
                = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        userService.test();
    }

Aop

AOP概念： Aspect Oriented Programming：面向切面编程 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

AOP底层原理

AOP底层使用动态代理

1. 有接口情况，使用JDK动态代理：创建接口实现类代理对象，增强类的方法

2. 没有接口情况：使用CGLIB动态代理：创建子类的代理对象，增强类的方法

JDK动态代理实现 调用newProxyInstance方法

start object newProxyInstance(Classloader loader,类<?>[ ] interfaces,InvocationHandler h);

参数1：类加载器

参数2：增强方法所在的类，这个类实现的接口，支持多个接口

参数3：实现这个接口InvocationHandle，创建代理对象，写增强的部分

JDK代理步骤

1. 创建接口，定义方法

2. 创建实现类，实现方法（将方法功能增强）

3. 使用Proxy创建接口代理对象

代码： 接口类

public interface UserDao {
    public int sum(int a,int b);
    public String update(String id);
}

实现类

public class UserDaoImpl implements UserDao{

    public int sum(int a, int b) {
        return a+b;
    }

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

代理类

public class JDKProxy {
    public static void main(String[] args) {

        Class[] interfaces = {UserDao.class};
        //匿名内部类方式创建
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                return null;
//            }
//        });
        //常规方式 创建一个类再导入对象
        UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDapProxy(new UserDaoImpl()));
        System.out.println(userDao.sum(1, 2));
        System.out.println(userDao.update("3"));
    }
}
class UserDapProxy implements InvocationHandler{
    private Object object;

    public UserDapProxy(Object object) {
        this.object = object;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //方法执行前
        System.out.println("before "+method.getName()+ " 传递的参数： "+ Arrays.toString(args));
        //增强方法执行
        Object res = method.invoke(object, args);
        //方法执行后
        System.out.println("after "+object);

        return res;
    }
}

AOP常用术语

• 连接点：类里可被增强的方法称为连接点

• 切入点：实际真正被增强的方法称为切入点

• 通知（增强）：实际增强的逻辑部分称为通知增强 前置通知、后置通知、环绕通知、异常通知、最终通知

• 切面：是动作，把通知应用到切入点过程

使用前准备工作

• Spring框架一般基于AspectJ实现AOP操作 AspectJ：面向切面的框架 AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。 Aspect不是Spring的组成部分，独立的AOP框架，一般Aspect和Spring框架一起使用进行AOP操作

• 基于AspectJ实现AOP操作 基于xml配置文件实现 基于注解方式实现（常用）

• 在项目工程文件中引入AOP依赖包

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>

• 切入点表达式

切入点表达式作用：知道哪个类里面的方法进行增强

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

例1：execution(* aop.bookdao.add(…))

例2：execution(* aop.bookdao.*(…))

AOP操作（Aspect注解）

1. 创建类

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

2. 创建增强类，编写增强逻辑(UserProxy) 在增强类里面，创建方法，让不同方法代表不同通知类型

@Component
@Aspect //表明是代理对象 标记给配置文件看
public class UserProxy {
    //该注解表示前置通知
    @Before(value = "execution(* com.kk.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
}

3. 进行类通知的配置 在Spring配置文件中，开启注解扫描 使用注解创建上述对象 在增强类上面添加注解@Aspect

4. 配置不同类型的通知 在增强类里面 在作为通知方法上面添加通知类型注解 使用切入点表达式配置

@Component
@Aspect //表明是代理对象 标记给配置文件看
public class UserProxy {
    //该注解表示前置通知
    @Before(value = "execution(* com.kk.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
    @After(value = "execution(* src.aop.User.add(..))")
    public void after(){
        System.out.println("after...");
    }
    @AfterReturning(value = "execution(* src.aop.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
    @AfterThrowing(value = "execution(* src.aop.User.add(..))")
    public void afterThrowing(){
        System.out.println("after throwing...");
    }
    @Around(value = "execution(* src.aop.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
        System.out.println("环绕前...");
        proceedingJoinPoint.proceed();
        System.out.println("环绕后...");
    }
}

---

本文章使用limfx的vscode插件快速发布