spring之动态代理实战

最新推荐文章于 2024-05-05 17:52:43 发布
最新推荐文章于 2024-05-05 17:52:43 发布
阅读量165 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41650354/article/details/103792310

1、搭建dao层
 

package com.proxy.dao;



import com.proxy.entity.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import java.util.List;
public class AccountDaoImpl implements AccountDao {
    private QueryRunner queryRunner;
    public Account findAccountByName(String accountName) {
        try{
            List<Account> query = queryRunner.query(" select id,account_name,money from ac where account_name = ?", new BeanListHandler<Account>(Account.class), accountName);
        if(query == null || query.size() == 0){
            return null;
        }
        if(query.size() >= 2){
            throw  new RuntimeException("数据大约2条");
        }
            Account account = query.get(0);
            account.setAccountName(accountName);
       return  account;
        }catch (Exception e){
            throw  new RuntimeException(e);
        }
    }

    public void updateAccount(Account account) {
        try{
          queryRunner.update("update ac set money = ? where account_name = ?", account.getMoney(), account.getAccountName());
        }catch (Exception e){
            throw  new RuntimeException(e);
        }
    }
    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }
}

2、搭建service层
 

package com.proxy.service.impl;
import com.proxy.dao.AccountDao;
import com.proxy.entity.Account;
import com.proxy.service.AccountService;

/**
 * 问题：每个方法都写txManagement 事务方法
 *          代码比较臃肿，不易维护
 */

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;
    public Account findAccountByName(String accountName) {
            Account accountByName = accountDao.findAccountByName(accountName);
            return accountByName;
    }
    public void updateAccount(Account account) {
            accountDao.updateAccount(account);
        }
        
    public void transfer(String sourceName, String targetName, Float money) {

            //根据A名称查询出账户
            Account source = accountDao.findAccountByName(sourceName);
            //根据B名称查询出账户
            Account target = accountDao.findAccountByName(targetName);
            //转出账户减钱
            source.setMoney(source.getMoney() - money);
            //转入账户加钱
            target.setMoney(target.getMoney() + money);
            //更新转出账户
            accountDao.updateAccount(source);
            //更新转入账户
            accountDao.updateAccount(target);

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

3、配置bean.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">
    <!--配置service层-->
    <bean id="accountService" class="com.proxy.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <!--配置dao层-->
    <bean id="accountDao" class="com.proxy.dao.AccountDaoImpl">
        <property name="queryRunner" ref="queryRunner"></property>
    </bean>
    <!--配置QueryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
     <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://120.25.236.19:3306/practice?useSSL=false"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
</beans>

4、测试
 


import com.proxy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")  //classes = BeanConfiguration.class
public class TestMain {


    @Autowired
    private AccountService accountService;

    @Test
    public void test(){
       System.out.println(accountService.findAccountByName("aaa").getId());

    }

}


改造成代理模式，对业务层方法进行增强

5、创建ConnectionUtils
 

package com.spring.utils;


import javax.sql.DataSource;
import java.sql.Connection;

/**
 * 链接的工具类，它用于从数据源中获取一个链接,并且实现和线程的绑定
 */
public class ConnectionUtils {

    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * 获取当前线程上的链接
     */
    public Connection getThreadConnection(){
        //1、先从ThreadLocal上进行获取
        Connection connection = tl.get();
        //2、判断当前线程上是否有链接
        try{
            if(connection == null){
                //3、从数据源中获取一个链接,并存入ThreadLocal中
                connection = dataSource.getConnection();
                tl.set(connection);
            }
        }catch (Exception e){
            throw new RuntimeException(e);
        }
        return  connection;
    }


    public void removeConnection(){
        tl.remove();
    }

}

 

6、创建TransactionManagement
 

package com.spring.utils;

/**
 * 和事务相关的工具类，它3包含了，开启事务，提交事务、回滚事务、释放事务
 */
public class TransactionManagement {

    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }
    /**
     * 开启事务
     */
    public void beginTransaction(){

        try{
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    public void commit(){
        try{
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    public void rollback(){
        try{
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 释放连接
     */
    public void release(){
        try{
            connectionUtils.getThreadConnection().close();
            connectionUtils.removeConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

 

7、改造dao
 

package com.spring.dao;

import com.spring.entity.Account;

import com.spring.utils.ConnectionUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;


import java.util.List;


public class AccountDaoImpl implements AccountDao {

    private QueryRunner queryRunner;
    private ConnectionUtils connectionUtils;

    public Account findAccountByName(String accountName) {
        try{

            List<Account> query = queryRunner.query(connectionUtils.getThreadConnection()," select id,account_name,money from ac where account_name = ?", new BeanListHandler<Account>(Account.class), accountName);
        if(query == null || query.size() == 0){
            return null;
        }
        if(query.size() >= 2){
            throw  new RuntimeException("数据大约2条");
        }
            Account account = query.get(0);
            account.setAccountName(accountName);
       return  account;
        }catch (Exception e){
            throw  new RuntimeException(e);
        }
    }

    public void updateAccount(Account account) {
        try{
          queryRunner.update(connectionUtils.getThreadConnection(),"update ac set money = ? where account_name = ?", account.getMoney(), account.getAccountName());
        }catch (Exception e){
            throw  new RuntimeException(e);
        }
    }

    public QueryRunner getQueryRunner() {
        return queryRunner;
    }

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    public ConnectionUtils getConnectionUtils() {
        return connectionUtils;
    }

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


8、创建代理对象的工厂
 

package com.spring.proxy;

import com.spring.service.AccountService;
import com.spring.utils.TransactionManagement;

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

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

    private AccountService accountService;
    private  TransactionManagement txManagement;

    /**
     * 生成accountService的代理对象
     */
   public AccountService getAccountService(){
     return  (AccountService)Proxy.newProxyInstance(
             accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事务的支持
                     * @param proxy
                     * @param method
                     * @param args
                     * @return
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        Object returnValue = null;

                        try {
                            txManagement.beginTransaction();
                            returnValue = method.invoke(accountService, args);
                            txManagement.commit();
                            return returnValue;
                        } catch (Exception e) {
                            txManagement.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            txManagement.release();
                        }
                    }
                });
    }

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

    public TransactionManagement getTxManagement() {
        return txManagement;
    }

    public void setTxManagement(TransactionManagement txManagement) {
        this.txManagement = txManagement;
    }
}

 

9、改造bean.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">



    <!--配置service层-->
    <bean id="accountService" class="com.spring.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <!--配置dao层-->
    <bean id="accountDao" class="com.spring.dao.AccountDaoImpl">
        <property name="queryRunner" ref="queryRunner"></property>
        <property name="connectionUtils" ref="connectionUtils"></property>

    </bean>



    <!--配置代理的service-->
    <!--proxyAccountService 代理了 accountService  所以在control层调用，就调用代理-->
    <bean id="proxyAccountService" factory-bean="proxyBeanFactory" factory-method="getAccountService"></bean>

    <!--配置ProxyBeanFactory-->
    <bean id="proxyBeanFactory" class="com.spring.proxy.ProxyBeanFactory">
        <property name="txManagement" ref="transactionManagement"></property>
        <property name="accountService" ref="accountService"></property>
    </bean>

    <!--配置QueryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"></bean>

    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://120.25.236.19:3306/practice?useSSL=false"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>

    <!--配置Connection的工具类-->
    <bean id="connectionUtils" class="com.spring.utils.ConnectionUtils">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!--配置事务管理器-->
    <bean id="transactionManagement" class="com.spring.utils.TransactionManagement">
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

</beans>

 

10、测试
        在service设置报错，会正常回滚代码，

package com;

import com.spring.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;



@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")  //classes = BeanConfiguration.class
public class TestMain {


    @Autowired
    @Qualifier("proxyAccountService")
    private AccountService accountService;

    @Test
    public void test(){
        accountService.transfer("aaa","bbb", 100f);

    }

}

 

11、总结
  本次应用的代理是接口代理。将事务特性：创建、提交、回滚、释放做了代理，也是将事务直接切入到方法中，从而体现出了切面的特性，也就是AOP。

 

 

git地址：https://gitee.com/Xiaokeworksveryhard/dynamic_proxy.git

Java 动态代理详解与实战示例
微笑听雨
06-03 6726
Java 动态代理是一种强大的技术，可以在不修改现有代码的情况下为方法调用添加额外的行为。通过使用 InvocationHandler 和 Proxy 类，可以轻松地实现各种代理模式，如日志记录、性能监控等。这种机制在很多 Java 框架（如 Spring AOP）中得到了广泛应用。
Spring AOP原理详解：动态代理与实际应用
逆流的小鱼
05-29 3555
在Spring AOP中，可以使用注解或XML配置来定义切面和通知。
Spring中的动态代理
Lyzxii
10-30 7568
1.Spring AOP 就是要对目标进行代理对象的创建， Spring AOP是基于动态代理的，有动态代理机制： JDK动态代理和CGLIB动态代理 动态代理：在虚拟机内部，运行的时候，动态生成代理类(运行时生成，runtime生成) ，并不是真正存在的类， 一般格式： Proxy$$ （Proxy$$Customer） 静态代理：实际存在代理类 （例如：struts2 Action...
Spring Boot 教程：运行器
dancuowang的博客
08-11 291
【注】本文译自：https://www.tutorialspoint.com/spring_boot/spring_boot_runners.htm 应用运行器和命令行运行器接口可以让你的代码在 Spring Boot 应该启动之后执行，你可以使用这些接口让应用启动之后立即执行任何行为。本文为你细说详情。 应用运行器 应用运行器是一个接口，用于在 Spring Boot 应用启动之后执行代码。下面的代码展示了如何在主类文件中实现应用运行器接口： package com.tutor...
【问题记录】Spring FactoryBean + JDK动态代理实现网关代理
m0_64944491的博客
05-05 579
这套思路，个人感觉还是比较直观的，没有绕什么弯子。但是这里遗留了一个问题，如果我想通过 Spring Boot 自动装配直接把动态代理类注入到业务模块，应该怎么做？我的一个想法是通过 SPI 机制，但是这样会引入模块间循环依赖的问题。
Spring中的事务控制（上）
余温0218的博客
06-22 196
先来看我们数据库中的表： 我们要做的事情，就是熟悉的转账操作，不过这次是用Spring容器中进行的。 栗子：未开启事务的转账 1、首先提供一个账户的实体类 Account.java（具体参考上一篇博文，在此不做展示） 2、给出账户的持久层接口 IAccountDao.java public interface IAccountDao { /** * 更新 * @param account */ void updateAccount(Account account)
Day_62 Spring注解
qq_26942049的博客
12-21 436
1、IOC注解 Spring框架中有注解和XML两种配置方式,包括Spring中的IOC和AOP也一样,都有XML和注解两种方式两种方式各有千秋。 1.1、xml和注解的区别 1.1.1 XML配置 优点有： XML配置方式进一步降低了耦合，使得应用更加容易扩展，即使对配置文件进一步修改也 不需要工程进行修改和重新编译。 在处理大的业务量的时候，用XML配置应该更加好一些。因为XML更加清晰的表明了各个 对象之间的关系，各个业务类之间的调用。同时spring的相关配置也能一目了然。 ...
切面编程的艺术：Spring动态代理解析与实战
学而时习之，不亦说乎？温故而知新，可以为师矣！
01-04 8579
Spring中的动态代理是实现AOP（面向切面编程）的重要组成部分，本文将深入解析动态代理的原理与应用。我们将详细介绍Spring中的两种动态代理实现方式：JDK动态代理和CGLIB动态代理，并讨论它们的优缺点。文章还会提供实用的示例，演示如何使用动态代理来实现横切关注点，例如日志记录、性能监控等。
Spring AOP（动态代理）
Cheer_RIO的博客
08-16 708
使用注解：@Aspect使用注解 @PointcutAspectJ ⽀持三种通配符（ * ） ：匹配任意字符，只匹配⼀个元素（包，类，或⽅法，⽅法参数）（. .） ：匹配任意字符，可以匹配多个元素 ，在表示类时，必须和 * 联合使⽤。（+） ：表示按照类型匹配指定类的所有类，必须跟在类名后⾯，如 com.cad.Car+ ,表示继承该类的所有⼦类包括本身。
13-Spring动态代理
热门推荐
前路无畏的博客
11-03 1万+
上一篇：12-静态代理设计模式-为了引出spring动态代理https://blog.youkuaiyun.com/fsjwin/article/details/109461867 spring的动态代理很高端吗？ 其实本质上就是对静态代理的抽离，封装，试听高端的，目的就一个，更有利于程序员的使用，下面来介绍一下spring动态代理。 1.Spring动态代理的概念 概念：通过代理类为原始类(目标类)增加额外功能 好处：利于原始类(目标类)的维护 从这点看和静态代理一样一样的 2.Spring动态代理相关依赖的引入 &
spring实战全部源代码.zip
10-26
2. **依赖注入**：Spring的核心特性之一是依赖注入，它允许对象之间的关系在运行时动态配置，而不是硬编码在类内部。这样可以提高代码的可测试性和可维护性。 3. **Spring容器**：所有Spring应用的核心是Spring容器...
springcloud项目实战微服务架构源代码+文档说明（电商版一套完整架构）
09-18
消息中间件使用ActiveMQ、分布式任务调度系统使用XXLJOB、反向代理工具使用Nginx 日志管理插件工具使用lombok、分布式日志收集使用Logstash、解析JSON框架使用FastJson 数据安全加密使用MD5加盐和Base64、RSA、...
基因工程的操作工具和操作程序练习题.doc
08-04
基因工程的操作工具和操作程序练习题.doc
SIEMENS数控车床编程实例PPT.ppt
08-04
SIEMENS数控车床编程实例PPT.ppt
网站安全管理制度.doc
08-04
网站安全管理制度.doc
惠普HP LaserJet M1005 MFP打印机驱动程序
最新发布
08-04
惠普 HP LaserJet M1005 MFP 是一款面向中小企业和 SOHO 办公场景的黑白激光多功能一体机，集打印、复印、扫描三项核心功能于一体。具体功能如下： 打印功能：采用黑白激光打印技术，打印速度为 15ppm（Letter）/14ppm（A4），打印分辨率为 600×600dpi，借助 HP 分辨率增强技术（REt）和 FastRes 1200 技术，可实现高达 FastRes 1200dpi 的打印质量。支持手动双面打印，月打印负荷为 5000 页，标配 150 页进纸盒和 10 页优先进纸插槽，可打印 A4 幅面以下多种尺寸纸张，如 A5、B5 等，也可打印信封、明信片等介质。 复印功能：复印速度与打印速度相同，为 15ppm（Letter）/14ppm（A4），复印分辨率为 600×600dpi，支持 25%-400% 缩放复印，最大复印页数可达 99 份，还可设置复印数量、明暗度等参数。 扫描功能：采用平板式扫描平台和 CIS 扫描元件，光学分辨率高达 1200×1200dpi，增强分辨率可达 19200dpi，灰度级为 256，支持 JPEG、TIFF、PDF 等多种文件格式输出，方便用户根据需求选择。 其他功能：配备 Hi - Speed USB 2.0 端口，方便与电脑等设备连接。具备 “0 秒预热技术”，可缩短首页输出时间，降低功耗，延长打印寿命。支持 N-up 打印（即在一张纸上打印多页内容）和 EconoMode 省墨模式，可节省纸张和耗材。
上海大学-计算机网络-实验报告.doc
08-04
上海大学-计算机网络-实验报告.doc
基于单片机的逆变电源系统综合设计.docx
08-04
基于单片机的逆变电源系统综合设计.docx
单片机原理与接口试验指导书本科通信专业使用.doc
08-04
单片机原理与接口试验指导书本科通信专业使用.doc
Spring AOP：静态代理与动态代理深度解析与实战
本文将深入解析Spring AOP中的静态代理和动态代理两种机制，这两种代理模式在Spring框架中的应用对于理解和实现面向切面编程(AOP)至关重要。首先，让我们理解什么是代理。 代理是一种设计模式，它允许我们在不修改...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值