spring-6：动态代理机制

最新推荐文章于 2024-04-30 10:56:38 发布
最新推荐文章于 2024-04-30 10:56:38 发布
阅读量181 收藏
点赞数
分类专栏： JavaEE框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43157935/article/details/105004666
版权

首先看一下事务层的代码：

package ypy.dao;

import ypy.domain.Account;

import java.util.List;

public interface IAccountDao {
    List<Account> findAllAccount();

    Account findAccountById(Integer accountId);

    void saveAccount(Account account);

    void updateAccount(Account account);

    void deleteAccount(Integer acccountId);

    Account findAccountByName(String accountName);
}

package ypy.dao.impl;

import ypy.dao.IAccountDao;
import ypy.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import ypy.utils.ConnectionUtils;

import java.util.List;

/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {
    //bean.xml文件中没有提供数据源，因此在AccountDaoImpl中会导入工具类：ConnectionUtils来获取数据源连接
    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    private QueryRunner runner;

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }

    public List<Account> findAllAccount() {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account",new BeanListHandler<Account>(Account.class));
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Account findAccountById(Integer accountId) {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void saveAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"insert into account(id,name,money)values(?,?,?)",account.getId(),account.getName(),account.getMoney());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void updateAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void deleteAccount(Integer accountId) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Account findAccountByName(String accountName){
        try{
            List<Account> accounts = runner.query(connectionUtils.getThreadConnection(),"select * from account where name = ? ",new BeanListHandler<Account>(Account.class),accountName);
            if(accounts == null || accounts.size() == 0){
                return null;
            }
            if(accounts.size() > 1){
                throw new RuntimeException("返回结果错误！");
            }
            return accounts.get(0);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

接着看一下业务层的代码：

package ypy.service.impl;

import ypy.dao.IAccountDao;
import ypy.domain.Account;
import ypy.service.IAccountServiceDao;
import ypy.utils.TransactionManager;

import java.util.List;

public class AccountServiceImpl implements IAccountServiceDao {

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

    public List<Account> findAllAccount() {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            List<Account> accounts = accountDao.findAllAccount();
            //3.提交事务
            txManager.commit();
            //4.返回结果
            return accounts;
        }catch (Exception e){
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放连接
            txManager.release();
        }

    }

    public Account findAccountById(Integer accountId) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            Account account = accountDao.findAccountById(accountId);
            //3.提交事务
            txManager.commit();
            //4.返回结果
            return account;
        }catch (Exception e){
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放连接
            txManager.release();
        }
    }

    public void saveAccount(Account account) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.saveAccount(account);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }

    }

    public void updateAccount(Account account) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.updateAccount(account);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }

    }

    public void deleteAccount(Integer acccountId) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.deleteAccount(acccountId);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }

    }

    public void transfer(String sourceName, String targetName, Double money) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);
            //2.6更新转入账户
            accountDao.updateAccount(target);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
            e.printStackTrace();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }
}

通过上述的代码发现业务层的方法变得很臃肿，充斥着许多重复代码。并且业务层和事务控制方法高耦合。试想一下，如果我们提交、回滚、释放资源中任何一个代码进行变更，都需要修改业务层的代码，并且伴随着程序规模的扩大，此情况会更加严重。
解决此类情况，我们要使用动态代理技术。

动态代理

作用：
在不改变源码的基础上，对方法进行增强。
特点：
字节码随用随创建，随用随加载。
分类：
1、基于接口的动态代理。
2、基于子类的动态代理。

  • 基于接口的动态代理：
    * 涉及的类：Proxy
    * 提供者：JDK官方
    * 如何创建代理对象：
    * 使用Proxy类中的newProxyInstance方法
    * 创建代理对象的要求：
    * 被代理类最少实现一个接口，如果没有则不能使用
    * newProxyInstance方法的参数：
    * ClassLoader：类加载器
    * 它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
    * Class[]：字节码数组
    * 它是用于让代理对象和被代理对象有相同方法。固定写法。
    * InvocationHandler：用于提供增强的代码
    * 它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
    * 此接口的实现类都是谁用谁写。

基于接口的动态代理实例代码：

package ypy.factory;

import ypy.service.IAccountService;
import ypy.utils.TransactionManager;

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

/**
 * 用于创建Service的代理对象的工厂
 */
public class BeanFactory {

    private IAccountService accountService;

    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }


    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    /**
     * 获取Service代理对象
     * @return
     */
    public IAccountService getAccountService() {
        return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object rtValue = null;
                        try {
                            //1.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            rtValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commit();
                            //4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });
    }
}


package ypy.service.impl;

import ypy.dao.IAccountDao;
import ypy.domain.Account;
import ypy.service.IAccountService;

import java.util.List;

/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
public class AccountServiceImpl implements IAccountService{

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public List<Account> findAllAccount() {
       return accountDao.findAllAccount();
    }

    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    public void deleteAccount(Integer acccountId) {
        accountDao.deleteAccount(acccountId);
    }

    public void transfer(String sourceName, String targetName, Double money) {
            System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            //2.6更新转入账户
            accountDao.updateAccount(target);
    }
}
  • 基于子类的动态代理：
    * 涉及的类：Enhancer
    * 提供者：第三方cglib库
    * 如何创建代理对象：
    * 使用Enhancer类中的create方法
    * 创建代理对象的要求：
    * 被代理类不能是最终类
    * create方法的参数：
    * Class：字节码
    * 它是用于指定被代理对象的字节码。
    * Callback：用于提供增强的代码
    * 它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
    * 此接口的实现类都是谁用谁写。
    * 我们一般写的都是该接口的子接口实现类：MethodInterceptor
    基于子类的动态代理我们另外举个实例代码：
    事务层代码：
package ypy.proxy;

public class Producer implements IProducer {
    public void saleProduct(Double money){
        System.out.println("sale"+money);
    }
    public void afterProduct(Double money){
        System.out.println("after"+money);
    }
}

基于子类的动态代理代码：

package ypy.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import ypy.proxy.IProducer;
import ypy.proxy.Producer;

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

public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();

        /**
         * 动态代理：
         *  特点：字节码随用随创建，随用随加载
         *  作用：不修改源码的基础上对方法增强
         *  分类：
         *      基于接口的动态代理
         *      基于子类的动态代理
         *  基于子类的动态代理：
         *      涉及的类：Enhancer
         *      提供者：第三方cglib库
         *  如何创建代理对象：
         *      使用Enhancer类中的create方法
         *  创建代理对象的要求：
         *      被代理类不能是最终类
         *  create方法的参数：
         *      Class：字节码
         *          它是用于指定被代理对象的字节码。
         *
         *      Callback：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。
         *          我们一般写的都是该接口的子接口实现类：MethodInterceptor
         */
        Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            /**
             * 执行北地阿里对象的任何方法都会经过该方法
             * @param proxy
             * @param method
             * @param args
             *    以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
             * @param methodProxy ：当前执行方法的代理对象
             * @return
             * @throws Throwable
             */
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //提供增强的代码
                Object returnValue = null;

                //1.获取方法执行的参数
                Double money = (Double) args[0];
                //2.判断当前方法是不是销售
                if("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer, money*0.80);
                }
                return returnValue;
            }
        });
            cglibProducer.saleProduct(100.00);
    }
}
风起的年华
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-Dynamic-Proxy:动态代理实现
07-14
- **AOP（面向切面编程）**：动态代理可以方便地实现在方法调用前后添加额外的行为，例如记录日志、性能监控、权限检查等切面逻辑。 - **缓存**：在调用实际方法前，代理对象可以先检查缓存，如果已存在结果，则...
spring-analysis：Spring源码阅读
02-16
Spring AOP通过代理模式实现，支持方法拦截、构造函数拦截以及环绕通知等多种拦截方式。理解AOP的工作原理，有助于编写更简洁、可维护的代码。 四、Spring MVC Spring MVC是Spring框架中的Web层组件，它提供了一种...
Spring6全面详解
weixin_45710998的博客
03-01 3474
　 自2022年11月，Spring6正式发布。在Spring6中，对于JDK的要求最低为 17+。（17 - 19） 部分文本摘抄于尚硅谷视频（bilibili）做了一定的排版和个人的理解。如果不是很熟悉，可以去看 [Spring5全面详解](http://t.csdn.cn/FgTQ7) 内容大约十万字左右， 对于Spring5的使用整理的较为全面，也都有解释部分，Spring6只是看以下是否具有一些特性上的更换。所以可能并没有Spring5的内容详细。但本篇大约在8-10万字左右。
Spring系列：Spring6简介和基本使用
程序人生
11-06 228
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。
Spring - 6 ( 9000 字 Spring 入门级教程 )
最新发布
weixin_73232539的博客
04-30 1120
spring 9000 字入门第六篇
Spring6详解-概述，入门
qq_33934592的博客
03-12 949
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。
Spring进阶（十）之动态代理详解
weixin_56644618的博客
10-03 984
jdk动态和cglib动态代理（重点）！！！
Spring6的新特性，正式“抛弃”feign了！
Java精选
01-28 2119
多数网友在对接第三方系统时，还在使用 httpclient、okhttp 等方式进行硬编码的形式实现对接。其实，我认为使用 feign 来实现更为方便快捷。feign 除了服务间的 http 调用外，还支持非服务间的 http 调用。只是，我们的一些思维还未转变过来，对 feign 的底层实现也缺乏一定的了解。近期，Spring 6 的第一个 GA 版本发布了，其中带来了一个新的特性——HTTP ...
spring-websocket:spring-websocket React器
07-11
- 使用 Spring Security 集成，提供身份验证和授权机制。 - 控制 WebSocket 访问权限，限制特定用户或角色连接。 7. **WebSocket 监控与调试** - Spring Boot Actuator 提供了监控 WebSocket 连接、消息统计等...
spring-learn:spring原始笔记
03-23
7. **代理（Proxy）**：Spring通过动态代理（JDK动态代理或CGLIB代理）来实现AOP功能，创建被通知的对象的代理对象。 三、Spring MVC 8. **Spring MVC**是Spring框架的一部分，用于构建Web应用程序。它提供了一个...
spring-source:spring
03-23
Spring通过动态代理实现AOP，有JDK代理和CGLIB代理两种方式，根据目标对象是否实现接口来选择。 3. **依赖注入（DI）** DI是IoC的具体实现，Spring通过XML配置、注解或Java配置来实现Bean之间的依赖关系。Spring...
Spring6-基础概念
Sakurapaid的博客
03-17 1045
Spring 是一套广泛应用于 Java 企业级应用开发领域的轻量级开源框架，由 Rod Johnson 创立，旨在显著降低 Java 企业应用的复杂性，缩短开发周期，并提升开发效率。Spring 不仅适用于服务器端开发，也因其简单的设计、卓越的可测试性和倡导的松耦合原则，使得几乎所有类型的 Java 应用都能从中获得好处。Spring 框架的核心价值在于提供了诸如控制反转（IoC）、面向切面编程（AOP）
spring6概述
m0_62946761的博客
09-26 3452
介绍spring6以及进行入门，包括加入log4j日志等
Spring的动态代理原理
Alexon Xu的博客
05-09 2013
Spring动态代理原理 Spring动态代理有两种：CGLIB动态代理和JDK动态代理。 JDK动态代理可以代理接口，不能代理没有实现接口的类；而CGLIB通过字节码技术可以动态生成被代理类的子类，从而可以代理没有实现接口的类；但是不能代理非public和final的方法，因为子类不可见。 Spring框架中使用DefaultAopProxyFactory来确定使用CGLIB或者JDK的动态代理 一般满足以下条件之一 就会进行CGLIB动态代理： optimize标志位被设定 proxyTargetCl
2023新版Spring6全新讲解-HelloSpring入门案例
波波烤鸭的博客
05-23 1076
Spring入门案例详解
SpringSecurity6从入门到上天系列第一篇：SpringSecurity6开篇介绍从概念开始把SpringSecurity6送上天
热门推荐
七叔的博客
10-30 2万+
本文是SpringSecurity6从入门到上天系列第一篇，让我们从概念开始把SpringSecurity6送上天
spring6入门
qq_21277357的博客
04-15 118
【代码】spring6入门。
spring 动态代理
weixin_44214857的博客
06-10 2150
感觉不错 三连支持 一起进步！动态代理。
ork.cloud:spring-cloud-starter-openfeign:jar:
07-16
### 回答1： ork.cloud:spring-cloud-starter-...通过引入这个jar包，我们可以一键集成和启用spring-cloud-starter-openfeign组件，省去了手动添加依赖和配置的步骤，能够更快速地搭建起微服务架构中的服务调用机制。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值