Spring 使用注解开发、代理模式、AOP

这篇具有很好参考价值的文章主要介绍了Spring 使用注解开发、代理模式、AOP。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

使用注解开发

在Spring4之后,要使用注解开发,必须要保证AOP的包导入了

项目搭建:

  1. 在配置文件中导入约束,增加注解支持

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
    
        <context:annotation-config/>
    
    </beans>
    
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
    
        <!--指定要扫描的包,这个包下的注解就会生效-->
        <context:component-scan base-package="xyz.luck1y.pojo"/>
        <!--注解驱动的包,可以识别spring之外的注解,如前面说的@Resource等等-->
        <context:annotation-config/>
    
    </beans>
    

bean

  • 实体类

    @Component 注解

    package xyz.luck1y.pojo;
    
    import org.springframework.stereotype.Component;
    
    // 等价于xml中的 <bean id="user" class="com.luck1y.pojo.User/>
    // @Component 意为组件,说明这个类已经被Spring管理啦,在xml中配置了组件扫描
    @Component
    public class User {
        public String name = "刘子";
    }
    
  • 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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
    
        <!--指定要扫描的包,这个包下的注解就会生效-->
        <context:component-scan base-package="xyz.luck1y.pojo"/>
        <!--注解驱动的包,可以识别spring之外的注解,如前面说的@Resource等等-->
        <context:annotation-config/>
    
    </beans>
    
  • 测试:

    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import xyz.luck1y.pojo.User;
    
    public class MyTest {
        public static void main(String[] args) {
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            User user = context.getBean("user", User.class);
            System.out.println(user.name);
        }
    }
    

属性如何注入

package xyz.luck1y.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

// 等价于xml中的 <bean id="user" class="com.luck1y.pojo.User/>
// @Component 意为组件,说明这个类已经被Spring管理啦,在xml中配置了组件扫描
@Component
public class User {
    // 相当于<property name="name" value="刘子"/>
    // 如果是很复杂的配置,还是建议使用xml
    @Value("刘子")
    public String name;
    
    
    // 也可以写在set方法上
    @Value("刘子")
    public void setName(String name) {
        this.name = name;
    }
}

衍生的注解

@Component有几个衍生的注解,我们在web开发中,会按照MVC三层架构分层

  • dao层: @Repository 等价于pojo层的@Component

    package xyz.luck1y.dao;
    
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class UserDao {
    }
    
  • service层:@Service 同样等价于pojo层的@Component

    package xyz.luck1y.service;
    
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    }
    
  • controller层:(也就是以前的servlet层)@Controller还是等价于pojo层的@Component

    package xyz.luck1y.controller;
    
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class UserController {
    }
    

这样写的话,前面的xml配置文件中componment组件扫描范围要扩大:

<context:component-scan base-package="xyz.luck1y"/>

这四个注解功能是一样的,都是代表将某个类注册到Spring容器中,装配bean

作用域

// 单例
@Scope("singleton")
// 原型
@Scope("prototype")

小结

xml和注解:

  • xml更加万能,适用于任何场合!维护简单方便
  • 注解:不是自己的类用不了,无法引用别的类,维护相对复杂

最佳实践:

  • xml用来管理bean
  • 注解用来完成属性的注入
  • 我们在使用的过程中需要注意必须要让注解生效,即在配置文件中开启注解支持

使用Java的方式配置Spring

完全不使用Spring的xml配置,全交给Java来做

JavaConfig是Spring的一个子项目,在Spring4之后,它成为了一个核心功能~

使用Java配置类来配置Spring

主配置类

package xyz.luck1y.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import xyz.luck1y.pojo.User;

// 相当于扫描包
@ComponentScan("xyz.luck1y.pojo")
// 这个也会被Spring容器托管,注册到容器中,因为它本来就是一个Component,它代表这是一个配置类,就是beans.xml
@Configuration
// 相当于xml中引入其他xml
@Import(MyConfig2.class)
public class MyConfig {
    // 注册一个 bean 就相当于我们之前写的<bean>标签
    // id 标签 就是这个方法的名字
    // class 标签 就是这个方法的返回值类型
    @Bean
    public User getUser(){
        return new User();
    }
}

配置类2

package xyz.luck1y.config;

import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig2 {
}

实体类:

package xyz.luck1y.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class User {
    @Value("刘子")
    public String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试:

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import xyz.luck1y.config.MyConfig;
import xyz.luck1y.pojo.User;

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

其实SpringBoot底层代码都是用以上注解方式写的,为什么说SpringBoot比Spring更强大呢,就是因为它在底层都固定写好了这些注解,拿过来直接用就好了~

代理模式

多线程那块提到过代理模式,这里再来学习一下代理模式

代理模式是SpringAOP的底层,SpringAOP和SpringMVC是面试重点

代理模式的分类:

  • 静态代理
  • 动态代理

静态代理

角色分析:

  • 抽象角色:一般会使用接口或抽象类来解决
  • 真实角色:被代理的角色
  • 代理角色:代理真实角色,代理真实角色后,会做一系列的附属操作
  • 客户:访问代理对象的人

代理模式的好处:

  • 可以使真实角色的操作更加纯粹,不用去关注其他的公共业务
  • 公共业务交给代理角色,实现了业务的分工(不需要给每一个房东都加相同的功能,这些相同的功能都提取到代理角色
  • 业务发生扩展的时候,方便集中管理

缺点:

  • 一个真实角色就会产生一个代理角色,真实角色变多时,代码量会翻倍,开发效率会变低
  • 为了解决这个问题,便有了动态代理

测试:

  1. 租房接口

    package xyz.luck1y;
    
    // 租房的接口
    public interface Rent {
        public void rent();
    }
    
  2. 房东:真实角色

    package xyz.luck1y;
    
    public class Host implements Rent {
        @Override
        public void rent() {
            System.out.println("房东要出租房子");
        }
    }
    
  3. 中介:代理角色

    package xyz.luck1y;
    
    public class Proxy implements Rent {
        private Host host;
    
        public Proxy(){
    
        }
    
        public Proxy(Host host) {
            this.host = host;
        }
    
        @Override
        public void rent() {
            seeHouse();
            host.rent();
            heTong();
            fee();
        }
    
        // 看房
        public void seeHouse(){
            System.out.println("中介带你看房");
        }
    
        // 签合同
        public void heTong(){
            System.out.println("签署租赁合同");
        }
    
        // 收中介费
        public void fee(){
            System.out.println("收中介费");
        }
    }
    
  4. 客户我们:

    package xyz.luck1y;
    
    public class Client {
    
        public static void main(String[] args) {
            // 房东要租房子
            Host host = new Host();
            // 代理,中介来帮房东租房子,但是中介一般有一些其他操作
            Proxy proxy = new Proxy(host);
            // 你不用面对房东,直接找中介租房就行
            proxy.rent();
    
        }
    }
    

加深理解

  1. 接口:

    package xyz.luck1y.Demo02;
    
    public interface UserService {
        public void add();
        public void delete();
        public void update();
        public void query();
    }
    
  2. 真实对象:

    package xyz.luck1y.Demo02;
    // 真实对象
    public class UserServiceImpl implements UserService {
        @Override
        public void add() {
            System.out.println("增加了一个用户");
        }
    
        @Override
        public void delete() {
            System.out.println("删除了一个用户");
        }
    
        @Override
        public void update() {
            System.out.println("修改了一个用户");
        }
    
        @Override
        public void query() {
            System.out.println("查询了一个用户");
        }
    }
    
  3. 代理对象:

    package xyz.luck1y.Demo02;
    
    public class UserServiceProxy implements UserService {
    
        private UserServiceImpl userService;
    
        public void setUserService(UserServiceImpl userService) {
            this.userService = userService;
        }
    
        @Override
        public void add() {
            log("add");
            userService.add();
        }
    
        @Override
        public void delete() {
            log("delete");
            userService.delete();
        }
    
        @Override
        public void update() {
            log("update");
            userService.update();
        }
    
        @Override
        public void query() {
            log("query");
            userService.query();
        }
    
        // 日志
        public void log(String msg){
            System.out.println("[Debug] 使用了" + msg + "方法");
        }
    }
    
  4. 客户端:

    package xyz.luck1y.Demo02;
    
    public class Client {
        public static void main(String[] args) {
            UserServiceImpl userService = new UserServiceImpl();
            UserServiceProxy userServiceProxy = new UserServiceProxy();
            userServiceProxy.setUserService(userService);
            userServiceProxy.add();
        }
    }
    

为什么不直接在原来的真实对象类加新的内容?

  • 改动原有的业务代码,在工作中是大忌,新增一个类,本来跑的好好的,崩了怎么办~

加一个代理类,可以在原有业务代码不变的基础上进行安全地附加操作

关于AOP

动态代理

  • 动态代理和静态代理的角色一样

  • 动态代理的代理类是动态生成的不是我们直接写好的

  • 动态代理也分为两大类:基于接口的动态代理、基于类的动态代理

    • 基于接口的动态代理【我们在这里使用这种方式】:JDK的动态代理

    • 基于类的动态代理:cglib

    • Java字节码实现:javasist

需要了解两个类:Proxy(代理),InvocationHandler(调用处理程序)

  • InvocationHandler:

    一个接口,java.lang.reflect,反射包下

    InvocationHandler是由代理实例的调用处理程序实现的接口,每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时,方法调用将被编码并分派到其调用处理程序的invoke方法。

    这个接口只有一个方法:Object invoke(Object proxy , 方法 method , Object[] args) throws Throwable

  • Proxy:

    一个类,java.lang.reflect,反射包下

    Proxy提供了创建动态代理类和实例的静态方法,它也是由这些方法创建的所有动态代理类的超类。也就说说可以通过类来调用方法。

代码实现:

自动生成代理类:

package xyz.luck1y.Demo03;

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

// 用这个类自动生成代理类
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);
    }

    // 处理代理实例,并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 动态代理的本质就是通过反射机制实现
        log(method.getName());
        seeHose();
        Object result = method.invoke(rent, args);
        getFee();
        return null;
    }

    public void seeHose(){
        System.out.println("中介带着看房子");
    }

    public void getFee(){
        System.out.println("收取中介费用");
    }

    public void log(String msg) {
        System.out.println("[Log] 执行了" + msg + "方法");
    }
}

客户端:

package xyz.luck1y.Demo03;

import xyz.luck1y.Demo02.UserServiceImpl;

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

房东和租房接口:

package xyz.luck1y.Demo03;

public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}
package xyz.luck1y.Demo03;

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

测试结果:

进一步观察:

package xyz.luck1y.Demo04;

import xyz.luck1y.Demo03.Rent;

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

// 用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    // 被代理的接口
    private Object target;

    public void setTarget(Object target){
        this.target = target;
    }

    // 生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    // 处理代理实例,并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 动态代理的本质就是通过反射机制实现
        log(method.getName());
        seeHose();
        Object result = method.invoke(target, args);
        getFee();
        return null;
    }

    public void seeHose(){
        System.out.println("中介带着看房子");
    }

    public void getFee(){
        System.out.println("收取中介费用");
    }

    public void log(String msg) {
        System.out.println("[Log] 执行了" + msg + "方法");
    }
}
package xyz.luck1y.Demo04;

import xyz.luck1y.Demo02.UserService;
import xyz.luck1y.Demo02.UserServiceImpl;
import xyz.luck1y.Demo03.Host;
import xyz.luck1y.Demo03.Rent;

public class Client {
    public static void main(String[] args) {
        // 真实角色
        UserServiceImpl userService = new UserServiceImpl();
        // 代理角色不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);
        // 动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
    }
}

动态代理的优点:

  • 可以使真实角色的操作更加纯粹,不用去关注真实角色的公共业务
  • 公共业务交给代理角色,实现了业务的分工(例子中,不需要给每一个房东都加相同的功能,这些相同的功能都提取到代理角色)
  • 业务发生扩展的时候,方便集中管理
  • 一个动态代理类代理的是一个接口,一般就是对应的一类业务
  • 一个动态代理类可以代理多个类,只要是实现类同一个接口即可。

AOP

什么是AOP

AOP (Aspect Oriented Programming)意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是0OP的延续,是软件开发中一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低提高程序的可重用性,同时提高了开发的效率

AOP在Spring中的作用

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

  • 横切关注点:跨越应用程序多个模块的方法或功能,即,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志、安全、缓存、事务等等
  • 切面(Aspect):横切关注点 被模块化的特殊对象,即,它是一个类
  • 通知(Advice):切面必须要完成的工作,即,它是类中的一个方法
  • 目标(Target):被通知对象
  • 代理(Proxy):向目标对象应用通知之后创建的对象
  • 切入点(PointCut):切面通知执行的“地点”的定义
  • 连接点(JoinPoint):与切入点匹配的执行点

在SpringAOP中:通过Advice定义横切逻辑,Spring支持五种类型的Advice:

即AOP可以在不改变原有代码的情况下,为业务增加新的功能。

使用Spring实现AOP

AOP织入包,需要导入一个依赖包!

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>
方式一:使用Spring的API接口

接口:

package xyz.luck1y.service;

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

实现类:

package xyz.luck1y.service;

public class UserServiceImpl implements UserService {

    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");
    }
}

AOP增加日志功能:

package xyz.luck1y.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

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

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

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

xml配置文件:

注意在前面写好aop约束

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userService" class="xyz.luck1y.service.UserServiceImpl"/>
    <bean id="log" class="xyz.luck1y.log.Log"/>
    <bean id="afterLog" class="xyz.luck1y.log.AfterLog"/>
    
	<!--方式一:使用原生的Spring API接口-->
    <!--配置aop:需要导入aop的约束-->
    <aop:config>
        <!--切入点:expression表达式,execution(要执行的位置! 修饰词 返回值 类名 方法名 参数)  .. 代表有任意的参数-->
        <aop:pointcut id="pointcut" expression="execution(* xyz.luck1y.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试:

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import xyz.luck1y.service.UserService;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
        // 动态代理代理的是接口,此处为 UserService 接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

结果:

方式二:自定义类实现实现AOP

自定义切面插入类:

package xyz.luck1y.diy;

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

    public void after(){
        System.out.println("=============方法执后=============");
    }
}

配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userService" class="xyz.luck1y.service.UserServiceImpl"/>
    <bean id="log" class="xyz.luck1y.log.Log"/>
    <bean id="afterLog" class="xyz.luck1y.log.AfterLog"/>
    <!--方式二:自定义类-->
    <!--比第一类简单,但是功能没有第一种强大-->
    <bean id="diy" class="xyz.luck1y.diy.DiyPointCut"/>

    <aop:config>
        <!--自定义切面,ref:要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* xyz.luck1y.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:before method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

测试:

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import xyz.luck1y.service.UserService;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
        // 动态代理代理的是接口,此处为 UserService 接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

结果:

方式三:使用注解实现AOP

package xyz.luck1y.diy;
// 方式三:使用注解方式实现AOP

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(* xyz.luck1y.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("========方法执行前========");
    }

    @After("execution(* xyz.luck1y.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("========方法执行后========");
    }

    // 在环绕增强中,我们可以给定一个参数,代表我们要获取处理切入的点
    @Around("execution(* xyz.luck1y.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("========环绕前========");
        // 获得签名
        Signature signature = joinPoint.getSignature();
        System.out.println("signature:" + signature);
        // 执行方法
        Object proceed = joinPoint.proceed();
        System.out.println("========环绕后========");
        System.out.println(proceed);
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userService" class="xyz.luck1y.service.UserServiceImpl"/>
    <bean id="log" class="xyz.luck1y.log.Log"/>
    <bean id="afterLog" class="xyz.luck1y.log.AfterLog"/>
    <!--方式三:使用注解-->
    <bean id="annotationPointCut" class="xyz.luck1y.diy.AnnotationPointCut"/>
    <!--开启注解支持   JDK(默认实现)  CGLib-->
    <!--proxy-target-class 设置为 false 为 JDK 实现,true 是 CGLib 实现-->
    <aop:aspectj-autoproxy proxy-target-class="false"/>
</beans>

测试结果:文章来源地址https://www.toymoban.com/news/detail-646669.html

到了这里,关于Spring 使用注解开发、代理模式、AOP的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Spring AOP (面向切面编程)原理与代理模式—实例演示

    Spring 中文文档 (springdoc.cn) Spring | Home 官网         Java是一个面向对象(OOP)的语言,但它有一些弊端。虽然使用OOP可以通过组合或继承的方式来实现代码的重用。但当我们需要为多个不具有继承关系的对象(一般指的是两个不同的类,它们之间没有继承自同一个父类或接

    2024年02月15日
    浏览(56)
  • B057-spring增强 依赖注入 AOP 代理模式 创建Bean

    DI:依赖注入 环境准备,即写一个spring测试,见工程 构造器注入 即使用构造器来给Bean的对象的属性赋值 MyBean OtherBean SpringTest-Context.xml SpringTest setter方法注入 即用setter方法给bean对象的属性赋值 MyBean OtherBean SpringTest-Context.xml SpringTest AOP 概念 事务管理:比如可以抽取try catch的

    2024年02月12日
    浏览(50)
  • Spring AOP 学习(动态代理、JdbcTemplate、Junit)

    Proxy  jdk动态代理,面向接口 cglib   第三方动态代理,面向父类 在 不修改原有代码 ,或者没有办法修改原有代码的情况下, 增强对象功能 ,使用代理对象代替原来的对象去完成功能,进而达到拓展功能的目的 JDK Proxy 动态代理是 面向接口 的动态代理,一定要有接口和实现

    2024年02月08日
    浏览(43)
  • 【Spring】使用自定义注解方式实现AOP鉴权

    AOP,是一种面向切面编程,可以通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 在软件开发中,鉴权(Authentication)是一项非常重要的安全措施,用于验证用户身份和权限。在应用程序中,我们通常会使用AOP(Aspect-Oriented Programming)来实现鉴权功能

    2024年02月11日
    浏览(48)
  • Spring02-Spring注解的使用、基于注解的IOC、纯注解配置、整合Junit、AOP入门、基于配置文件的AOP、切入点表达式、基于配置的文件环绕通知

    学习基于注解的 IOC 配置,即注解配置 和 XML 配置要实现的功能都是一样的,都是要降低程序间的耦合。只是配置的形式不一样。 关于实际的开发中到底使用xml还是注解,每家公司有着不同的使用习惯 , 所以这两种配置方式我们都需要掌握。 把 Spring 的 xml 配置内容改为使用

    2024年02月03日
    浏览(76)
  • Spring Boot学习随笔- 实现AOP(JoinPoint、ProceedingJoinPoint、自定义注解类实现切面)

    学习视频:【编程不良人】2021年SpringBoot最新最全教程 问题 现有业务层开发存在问题 额外功能代码存在大量冗余 每个方法都需要书写一遍额外功能代码不利于项目维护 Spring中的AOP AOP:Aspect 切面 + Oriented 面向 Programmaing 面向切面编程 Aspect(切面) = Advice(通知) + Pointcut(

    2024年02月04日
    浏览(48)
  • 【Spring】使用aop切面编程时要给那些类加注解

    🎄欢迎来到@边境矢梦°的csdn博文🎄  🎄本文主要梳理 Spring 中使用aop切面编程时要给那些类加注解 🎄 🌈我是边境矢梦°,一个正在为秋招和算法竞赛做准备的学生🌈 🎆喜欢的朋友可以关注一下 🫰🫰🫰 ,下次更新不迷路🎆 Ps: 月亮越亮说明知识点越重要 (重要性或者

    2024年02月07日
    浏览(48)
  • 全面掌握Spring框架:深入解析IOC、AOP、事务管理与注解使用

    探索Spring框架的深层次知识,包括Spring IOC容器的初始化流程、AOP的实现机制、事务管理的细节、循环依赖问题的处理、条件注解的应用、JavaConfig的使用方法、PostProcessor的角色、@Autowired和@Value注解的高级应用,以及${}与#{}的区别。

    2024年03月13日
    浏览(196)
  • 注解实现(基于Spring AOP)

    切入点表达式 Spring AOP 支持的切入点主要有以下几种: execution:用于匹配方法执行的连接点。这是最常用的切入点指示器。你可以指定具体的方法,或者类来匹配。 例如: execution(* com.example.service.*.*(..)) ,这个表达式表示匹配 com.example.service 包下的所有类的所有方法。 wit

    2024年02月16日
    浏览(42)
  • spring boot 使用AOP+自定义注解+反射实现操作日志记录修改前数据和修改后对比数据,并保存至日志表

    使用FieldMeta自定义注解,看个人业务自行觉得是否需要重新定义实体 实现类 :通过该实现类获取更新前后的数据。 该实现类的实现原理为:获取入参出入的id值,获取sqlSessionFactory,通过sqlSessionFactory获取selectByPrimaryKey()该方法,执行该方法可获取id对应数据更新操作前后的数

    2024年01月23日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包