Spring学习笔记3

最新推荐文章于 2024-07-08 00:05:07 发布

欢乐的每一天

最新推荐文章于 2024-07-08 00:05:07 发布

阅读量88

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/a3026836480/article/details/108600466

版权

笔记专栏收录该内容

37 篇文章 1 订阅

订阅专栏

10 代理模式

SpringAOP的底层实现基于代理模式[SpringAOP和SpringMVC]
代理模式分类：静态代理，动态代理

10.1 静态代理

角色分析：
抽象角色：一般会使用接口或抽象类来实现
真实角色：被代理的角色
代理角色：代理真实角色，一般会有一些附属操作
客户：访问代理对象的人
静态代理例子(中介帮房东出租房子)

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

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

package demo;
//代理
public class Proxy implements Rent {
    private Host host;
    public Proxy(){}
    public Proxy(Host host)
    {
        this.host=host;
    }
    public void rent() {
        seeHouse();
        host.rent();
        signContract();
    }
    public void seeHouse()
    {
        System.out.println("看房");
    }
    public void signContract()
    {
        System.out.println("签合同");
    }
}

package demo;

public class Client {
    public static void main(String[] args) {
        Host host=new Host();
        //代理
        Proxy proxy=new Proxy(host);
        proxy.rent();
    }
}

静态代理模式的好处：
可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
公共业务交给代理角色，实现了业务的分工
公共业务发生扩展的时候，方便集中管理
缺点：
一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率变低
静态代理例子2
使用代理添加日志功能

package demo2;

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

package demo2;

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 find() {
        System.out.println("查找一个用户");
    }
}

package demo2;

public class Proxy implements UserService {
    UserServiceImpl service;
    public Proxy(){}
    public Proxy(UserServiceImpl service)
    {
        this.service=service;
    }
    public void add() {
        log("add");
        service.add();
    }

    public void delete() {
        log("delete");
        service.delete();
    }

    public void update() {
        log("update");
        service.update();
    }

    public void find() {
        log("find");
        service.find();
    }
    //操作日志
    public void log(String msg)
    {
        System.out.println("使用了"+msg+"方法");
    }
}

package demo2;

public class Client {
    public static void main(String[] args) {
        //被代理对象
        UserServiceImpl service=new UserServiceImpl();
        //代理对象
        Proxy proxy=new Proxy(service);
        proxy.add();
    }
}

10.2 动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是程序员直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理

基于接口–JDK动态代理(下面的举例使用)
基于类：cglib
java字节码实现：javasist
需要了解两个类：Proxy：代理 InvocationHandler：调用处理程序
动态代理例子(中介帮房东出租房子)

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

package demo3;

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

package demo3;

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

    }
    //处理代理实例，返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的实质就是使用反射机制实现
        seeHouse();
        //method.invoke(rent,args);
        //即调用rent对象的方法(method对应的具体方法)
        Object result=method.invoke(rent,args);
        signContact();
        return result;
    }
    public void seeHouse()
    {
        System.out.println("中介带领看房子");
    }
    public void signContact()
    {
        System.out.println("签合同");
    }
}

package demo3;

public class Client {
    public static void main(String[] args) {
        //被代理对象
        Host host=new Host();
        ProxyInvocationHandler handler=new ProxyInvocationHandler();
        handler.setRent(host);
        //代理对象
        Rent proxy= (Rent) handler.getProxy();
        proxy.rent();
    }
}

动态代理，调用处理程序模板

package demo3;

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

public class Handler 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 {
        //在这个方法里加上附加操作
        Object result=method.invoke(target,args);
        return result;
    }
}

11 AOP

11.1 什么是AOP

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

11.2 AOP在Spring中的作用

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

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

SpringAOP中通过Advice定义横切逻辑，Spring中支持5种类型的Advice

通知类型	连接点	实现接口
前置通知	方法前	org.springframework.aop.MethodBeforeAdvice
后置通知	方法后	org.springframework.aop.AfterReturningAdvice
环绕通知	方法前后	org.aopalliance.intercept.MethodInterceptor
异常抛出通知	方法抛出异常	org.springframework.aop.ThrowsAdvice
引介通知	类中增加新的方法属性	org.springframework.aop.IntroductionInterceptor

即AOP在不改变原有代码的情况下，增加新功能

11.3 使用Spring实现AOP

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

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

方式一：使用Spring的API接口

package service;

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

package service;

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 find() {
        System.out.println("查询用户");
    }
}

package log;

import org.springframework.aop.MethodBeforeAdvice;

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

package log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

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

<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
    <bean id="userService" class="service.UserServiceImpl"></bean>
    <bean id="log" class="log.Log"></bean>
    <bean id="afterLog" class="log.AfterLog"></bean>
<!--    方式一：使用Spring API接口-->
<!--    配置AOP，需要导入aop约束-->
    <aop:config>
<!--        要执行的切入点expression表达式 execution(要执行的位置)-->
        <aop:pointcut id="pointcut" expression="execution(* service.UserServiceImpl.*())"/>

<!--        执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"></aop:advisor>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor>
    </aop:config>
</beans>

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

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

在这里插入图片描述
方式二：自定义来实现AOP

package 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 https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userService" class="service.UserServiceImpl"></bean>
    <bean id="log" class="log.Log"></bean>
    <bean id="afterLog" class="log.AfterLog"></bean>
    
    <!--方式二：自定义类-->
    <bean id="diy" class="diy.DiyPointCut"></bean>
    <aop:config>
    <!--自定义切面，ref 要引用的类-->
     <aop:aspect ref="diy">
         <!--切入点-->
         <aop:pointcut id="point" expression="execution(* service.UserServiceImpl.*(..))"/>
         <!--通知-->
         <aop:before method="before" pointcut-ref="point"></aop:before>
         <aop:after method="after" pointcut-ref="point"></aop:after>
     </aop:aspect>
    </aop:config>
</beans>

其他代码不变
Test.main执行结果
在这里插入图片描述
方式三：使用注解实现

package diy;

import org.aspectj.lang.ProceedingJoinPoint;
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(* service.UserServiceImpl.*(..))")
    public void before()
    {
        System.out.println("方法执行前----");
    }
    @After("execution(* service.UserServiceImpl.*(..))")
    public void after()
    {
        System.out.println("方法执行后----");
    }
    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //执行方法
        Object proceed=jp.proceed();
        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 https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userService" class="service.UserServiceImpl"></bean>
    <bean id="log" class="log.Log"></bean>
    <bean id="afterLog" class="log.AfterLog"></bean>
    <!--方式三-->
    <bean id="diy" class="diy.AnnotationPointCut"></bean>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>
</beans>