栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring5(下)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring5(下)

Spring5(下) 代理模式

为什么要学习代理模式?因为这就是spring AOP的底层! 【Spring AOP和 Spring MVC】

代理模式的分类:

  • 静态代理
  • 动态代理
静态代理

角色分析:

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

代码步骤:

  1. 接口

    //租房
    public interface Rent {
        public void rent();
    }
    
  2. 真实角色

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

    //中介
    public class Proxy implements Rent{
        private Host host;   //使用组合方式:多用组合,少用继承
    
        public Proxy() {
        }
    
        public Proxy(Host host) {
            this.host = host;
        }
    
        @Override
        public void rent() {
            seeHouse();
            contract();
            fare();
            host.rent();   //帮房东租房子
        }
    
        //看房
        public void seeHouse(){
            System.out.println("中介带你看房");
        }
        //签合同
        public void contract(){
            System.out.println("签租赁合同");
        }
        //收中介费
        public void fare(){
            System.out.println("收中介费");
        }
    }
    
  4. 客户端访问代理角色

    //客户
    public class Client {
        public static void main(String[] args) {
            //房东要租房子
            Host host = new Host();
            //代理,中介帮房东租房子,但是呢?代理角色一般会有一些附属操作
            Proxy proxy = new Proxy(host);
            //你不用面对房东,直接找中介租房即可!
            proxy.rent();
        }
    }
    

代理模式的好处:

  • 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
  • 公共业务也就交给了代理角色!实现了业务的分工!
  • 公共业务发生扩展的时候,方便集中管理!

缺点:一个真实角色就会产生一个代理角色;代码量会翻倍,开发效率会变低

加深理解

代码步骤:

  1. 接口

    public interface UserService {
        public void add();
        public void delete();
        public void update();
        public void query();
    }
    
  2. 真实角色

    //真实对象
    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. 代理角色

         
    public class UserServiceProxy implements UserService{
        private UserServiceImpl userService;
    
        //spring注入一个对象建议使用set方法
        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("使用了"+msg+"方法");
        }
    }
    
  4. 客户端访问

    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:调用处理程序

代码步骤:

  1. 接口

    //租房
    public interface Rent {
        public void rent();
    }
    
  2. 真实角色

    //房东
    public class Host implements Rent {
        @Override
        public void rent() {
            System.out.println("房东要出租房子了");
        }
    }
    
  3. 代理调用处理程序

    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;
        }
    
        //生成得到代理类直接通过newProxyInstance:这段代码是死的!只需要修改被代理的接口 rent.getClass().getInterfaces()参数
        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 {
            //调用代理类之前执行seeHouse()方法
            seeHouse();
            //动态代理的本质就是使用反射机制实现
            Object result = method.invoke(rent, args);
            //调用代理类之后执行fare()方法
            fare();
            return result;
        }
        public void seeHouse(){
            System.out.println("中介带看房子");
        }
        public void fare(){
            System.out.println("收中介费");
        }
    }
    
  4. 客户端访问

    public class Client {
        public static void main(String[] args) {
            //真实角色
            Host host = new Host();
            //代理角色:现在没有,需要使用ProxyInvocationHandler类生成
            ProxyInvocationHandler pih = new ProxyInvocationHandler();
            //通过调用程序处理角色来处理我们要调用的接口对象!
            pih.setRent(host);
            //动态生成代理类proxy,我们并没有写它
            Rent proxy = (Rent) pih.getProxy();
    
            //使用代理类调用方法
            proxy.rent();
        }
    }
    

动态代理的好处:

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

代码步骤:

  1. 生成模板类(直接套用即可)

    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;
        }
    
        //生成得到代理类直接通过newProxyInstance:这段代码是死的!只需要修改被代理的接口 rent.getClass().getInterfaces()参数
        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());
            //动态代理的本质就是使用反射机制实现
            Object result = method.invoke(target, args);
    
            return result;
        }
        public void log(String msg){
            System.out.println("执行了"+msg+"方法");
        }
    }
    
  2. 客户访问类(只需要修改此类即可实现)

    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.delete();
        }
    }
    
AOP 什么是AOP

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

AOP在Spring中的作用

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

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


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


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

使用Spring实现AOP

【重点】使用AOP织入,需要导入一个依赖包!


    
    
        org.aspectj
        aspectjweaver
        1.9.4
    

方式一:使用spring的接口
  1. UserService接口

    public interface UserService {
        public void add();
        public void delete();
        public void update();
        public void query();
    }
    
  2. UserServiceImpl实现类

    public class UserServiceImpl implements UserService{
        @Override
        public void add() {
            System.out.println("增加了一个用户, 学号:191107410070 姓名:舒必发");
        }
    
        @Override
        public void delete() {
            System.out.println("删除了一个用户");
        }
    
        @Override
        public void update() {
            System.out.println("修改了一个用户");
        }
    
        @Override
        public void query() {
            System.out.println("查询了一个用户");
        }
    }
    
  3. log——BeforeLog类

    import org.springframework.aop.MethodBeforeAdvice;
    
    import java.lang.reflect.Method;
    
    public class BeforeLog implements MethodBeforeAdvice {
        //method:要执行目标对象的方法
        //args:参数
        //target:目标对象
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("before: 方法执行前,"+target.getClass().getName()+"的"+method.getName()+"被执行了");
        }
    }
    
  4. log——AfterRunningLog类

    import org.springframework.aop.AfterReturningAdvice;
    
    import java.lang.reflect.Method;
    
    public class AfterReturningLog implements AfterReturningAdvice {
        //returnValue:返回值
        @Override
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
            System.out.println("afterRunning:方法执行后,执行了" + method.getName() + "返回结果为: " + returnValue);
        }
    }
    
  5. ApplicationContext.xml

    
    
    
        
        
        
        
    
        
        
        
            
            
    
            
            
            
    
        
    
    
  6. MyTest测试类

    public class MyTest {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
            //动态代理的是接口
            
            //UserService usi = (UserService)context.getBean("usi");
            UserService usi = context.getBean("usi",UserService.class);
            usi.add();
        }
    }
    
  7. 测试结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y1uPxRim-1653966872703)(C:UserskevinAppDataRoamingTyporatypora-user-imagesimage-20220504213323133.png)]

    方式二:自定义来实现AOP(diy类)
    • 定义切入点表达式
    execution(* com.shu.service.UserServiceImpl.*(..))
    

    具体含义:

    1、execution():表达式主体
    2、第一个*号:表示返回类型,号表示所有的类型
    3、包名:表示需要拦截的包名,后面的两个句点分别表示当前包和当前包的所有子包,com.sample.service.impl包、子孙包下所有类的方法
    4、第二个号:表示类名,号表示所有的类
    5、(…) :第三个星号表示方法名,*号表示所有的方法,后面括弧里面表示方法的参数,两个句点表示任何参数





    
    
        
        
        
        
        
    

事务 回顾事务
  • 把一组业务当成一个业务来做;要么都成功,要么都失败!
  • 事务在项目开发中,十分的重要,涉及到数据的一致性问题,不能马虎!
  • 确保完整性和一致性

事务的ACID原则:

  • A:原子性
  • C:一致性
  • I:隔离性
    • 多个业务可能操作同一个资源,防止数据损坏
  • D:持久性
    • 事务一旦提交,无论系统发生什么问题,结果都不会再被影响,被持久化的写到数据库中!

事务的原子性(Atomicity):是指一个事务要么全部执行,要么不执行,也就是说一个事务不可能只执行了一半就停止了。比如你从取款机取钱,这个事务可以分成两个步骤:1划卡,2出钱。不可能划了卡,而钱却没出来。这两步必须同时完成,要么就不完成。

事务的一致性(Consistency) :是指事务的运行并不改变数据库中数据的一致性。例如,完整性约束了a+b=10,一个事务改变了a,那么b也应该随之改变。

独立性(Isolation):事务的独立性也称作隔离性,是指两个以上的事务不会出现交错执行的状态。因为这样可能会导致数据不一致,更加具体的来讲,就是事务之间的操作是独立的。

持久性(Durability):事务的持久性是指事务执行成功以后,该事务对数据库所作的更改便是持久的保存在数据库之中,不会无缘无故的回滚。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/940953.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号