动态代理

最新推荐文章于 2023-02-23 13:33:47 发布
最新推荐文章于 2023-02-23 13:33:47 发布
阅读量163 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36074064/article/details/76434906
版权 
静态代理
spring06staticproxy包

Subject接口
package cn.happy.spring06staticproxy;
/**
 * 抽象主题
 * Created by Happy on 2017-07-30.
 */
public interface Subject {
    public String add();
}

RealSubject
package cn.happy.spring06staticproxy;

/**
 * Created by Happy on 2017-07-30.
 */
public class RealSubject implements Subject {
    public String add() {
        System.out.println("add ok!");
        return "";
    }
}
ProxySubject
package cn.happy.spring06staticproxy;

/**
 * Created by Happy on 2017-07-30.
 */
public class ProxySubject implements Subject {
    //对象间交互
    private Subject realSubject;
    public String add() {
        System.out.println("事务已经开启");
        return realSubject.add();
    }

    public Subject getRealSubject() {
        return realSubject;
    }

    public void setRealSubject(Subject realSubject) {
        this.realSubject = realSubject;
    }
}
测试
 @Test
    public void test01() {
        //真实主题对象
        Subject subject=new RealSubject();
        //代理对象
        ProxySubject proxySubject=new ProxySubject();

        proxySubject.setRealSubject(subject);
        proxySubject.add();
    }
JDK动态代理
spring07jdkdynamicproxy包
IUserDAO接口
package cn.happy.spring07jdkdynamicproxy;

/**
 * Created by Happy on 2017-07-30.
 */
public interface IUserDAO {
    public String add();
    public String edit();
}
UserDAOImpl
package cn.happy.spring07jdkdynamicproxy;

/**
 * Created by Happy on 2017-07-30.
 */
public class UserDAOImpl implements IUserDAO {
        public String add() {
            System.out.println("add");
            return "add";
        }

        public String edit() {
            System.out.println("edit");
            return "edit";
        }
}
测试
@Test
    public void test02() {
        final IUserDAO dao=new UserDAOImpl();
        IUserDAO proxy=(IUserDAO)Proxy.newProxyInstance(dao.getClass().getClassLoader(), dao.getClass().getInterfaces(), new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("事务已经开启");
                method.invoke(dao,args);
                return null;
            }
        });
        //代理对象add   edit
        proxy.add();
        proxy.edit();
    }
CGLIB动态代理
spring08cglibdynamicproxy包
UserService
package cn.happy.spring08cglibdynamicproxy;

/**
 * Created by Happy on 2017-07-30.
 */
public class UserService {
    //核心业务方法
    public void delete(){
        System.out.println("delete ok!");
    }
}
测试
 @Test
    public void test03() {
        final UserService service=new UserService();
        //Enhancer对象
        Enhancer enhancer=new Enhancer();
        //在内存中构建业务类的子类
        enhancer.setSuperclass(service.getClass());
        enhancer.setCallback(new MethodInterceptor() {
            /**
             * @param o  代理对象
             * @param method  代理对象方法
             * @param objects  参数
             * @param methodProxy
             */
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("事务已经开启");
                methodProxy.invoke(service,objects);
                return null;
            }
        });
        UserService proxy=(UserService)enhancer.create();
        proxy.delete();

    }
前置增强
spring09aop01包
ISomeService接口
package cn.happy.spring09aop01;

/**
 * Created by Happy on 2017-07-30.
 */
public interface ISomeService {
    public void doSome();
    public void doSecond();
}
MyBeforeAdvise
package cn.happy.spring09aop01;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * Created by Happy on 2017-07-30.
 */
//前置通知
public class MyBeforeAdvise implements MethodBeforeAdvice {

    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("=============log==================");
    }
}
SomeService
package cn.happy.spring09aop01;

/**
 * Created by Happy on 2017-07-30.
 */
public class SomeService implements ISomeService {
    //核心业务
    public void doSome(){
        System.out.println("我们都要找到Java开发工作，薪资6,7,8,9,10K");
    }

    public void doSecond() {
        System.out.println("doSecond");
    }
}
applicationContextspring07aop01.xml
 <!--01.目标对象-->
    <bean id="someService" class="cn.happy.spring09aop01.SomeService"></bean>

    <!--02.增强 通知-->
    <bean id="beforeAdvice" class="cn.happy.spring09aop01.MyBeforeAdvise"></bean>

    <!--03.aop -->
    <bean id="proxyService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--配置需要增强的目标对象-->
        <property name="target" ref="someService"></property>
        <!--做怎么样的增强-->
        <property name="interceptorNames" value="beforeAdvice"></property>
        <property name="proxyTargetClass" value="true"></property>
    </bean>
测试
@Test
    // 前置增强
    public void test04(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextspring07aop01.xml");
        SomeService service = (SomeService) ctx.getBean("proxyService");
        service.doSome();
        service.doSecond();
    }
后置增强
spring10afterreturingadvice

ISomeService接口
package cn.happy.spring10afterreturingadvice;

/**
 * Created by Happy on 2017-07-30.
 */
public interface ISomeService {
    public void doSome();
}
MyAfterReturningAdvice
package cn.happy.spring10afterreturingadvice;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

/**
 * Created by Happy on 2017-07-30.
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("===========after================");
    }
}
SomeService
package cn.happy.spring10afterreturingadvice;

/**
 * Created by Happy on 2017-07-30.
 */
public class SomeService implements ISomeService {
    //核心业务
    public void doSome(){
        System.out.println("我们都要找到Java开发工作，薪资6,7,8,9,10K");
    }
}
applicationContextspring08aop02.xml
 <!--01.目标对象-->
    <bean id="someService" class="cn.happy.spring10afterreturingadvice.SomeService"></bean>

    <!--02.增强 通知-->
    <bean id="afterAdvice" class="cn.happy.spring10afterreturingadvice.MyAfterReturningAdvice"></bean>

    <!--03.aop -->
    <bean id="proxyService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--配置需要增强的目标对象-->
        <property name="target" ref="someService"></property>
        <!--做怎么样的增强-->
        <property name="interceptorNames" value="afterAdvice"></property>

    </bean>
测试
@Test
    // 后置增强
    public void test05(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextspring08aop02.xml");
        ISomeService service = (ISomeService) ctx.getBean("proxyService");
        service.doSome();
    }
环绕增强
spring11methodinterceptor包
ISomeService接口
package cn.happy.spring11methodinterceptor;

/**
 * Created by Happy on 2017-07-30.
 */
public interface ISomeService {
    public void doSome();
}
MyMethodInterceptor
package cn.happy.spring11methodinterceptor;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * Created by Happy on 2017-07-30.
 */
public class MyMethodInterceptor implements MethodInterceptor {
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("before");
        methodInvocation.proceed();
        System.out.println("after");
        return null;
    }
}
SomeService
package cn.happy.spring11methodinterceptor;

/**
 * Created by Happy on 2017-07-30.
 */
public class SomeService implements ISomeService {
    //核心业务
    public void doSome(){
        System.out.println("我们都要找到Java开发工作，薪资6,7,8,9,10K");
    }
}
applicationContextspring09aop03.xml
<!--01.目标对象-->
    <bean id="someService" class="cn.happy.spring11methodinterceptor.SomeService"></bean>

    <!--02.增强 通知-->
    <bean id="methodAdvice" class="cn.happy.spring11methodinterceptor.MyMethodInterceptor"></bean>

    <!--03.aop -->
    <bean id="proxyService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--配置需要增强的目标对象-->
        <property name="target" ref="someService"></property>
        <!--做怎么样的增强-->
        <property name="interceptorNames" value="methodAdvice"></property>

    </bean>
测试
@Test
    // 环绕增强
    public void test06(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextspring09aop03.xml");
        ISomeService service = (ISomeService) ctx.getBean("proxyService");
        service.doSome();
    }
异常增强
spring12throwadvice包

IHHJJ接口
package cn.happy.spring12throwadvice;

/**
 * Created by Happy on 2017-07-30.
 */
public interface IHHJJ {
    public void run();
    public void run(String style);
}
ISomeService接口
package cn.happy.spring12throwadvice;

/**
 * Created by Happy on 2017-07-30.
 */
public interface ISomeService {
    public void doSome();
}
HHJJImpl
package cn.happy.spring12throwadvice;

/**
 * Created by Happy on 2017-07-30.
 */
public class HHJJImpl implements IHHJJ {
    public void run() {

    }

    public void run(String style) {

    }
}

MyThrowsAdvice
package cn.happy.spring12throwadvice;

import org.springframework.aop.ThrowsAdvice;

/**
 * Created by Happy on 2017-07-30.
 */
public class MyThrowsAdvice implements ThrowsAdvice {
    public void afterThrowing(Exception ex){
        System.out.println("错误");
    }

}
SomeService
package cn.happy.spring12throwadvice;

/**
 * Created by Happy on 2017-07-30.
 */
public class SomeService implements ISomeService {
    //核心业务
    public void doSome(){
        int result=5/0;
        System.out.println("我们都要找到Java开发工作，薪资6,7,8,9,10K");
    }
}

applicationContextspring10aop04.xml
<!--01.目标对象-->
    <bean id="someService" class="cn.happy.spring12throwadvice.SomeService"></bean>

    <!--02.增强 通知-->
    <bean id="throwsAdvice" class="cn.happy.spring12throwadvice.MyThrowsAdvice"></bean>

    <!--03.aop -->
    <bean id="proxyService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--配置需要增强的目标对象-->
        <property name="target" ref="someService"></property>
        <!--做怎么样的增强-->
        <property name="interceptorNames" value="throwsAdvice"></property>

    </bean>

测试
@Test
    // 异常增强
    public void test07(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextspring10aop04.xml");
        ISomeService service = (ISomeService) ctx.getBean("proxyService");
        service.doSome();
    }
名称匹配方法切入点顾问
spring13aopadvisor
ISomeService接口
package cn.happy.spring13aopadvisor;

/**
 * Created by Happy on 2017-07-30.
 */
public interface ISomeService {
    public void doSome();
    public void add();
}
MyBeforeAdvise
package cn.happy.spring13aopadvisor;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * Created by Happy on 2017-07-30.
 */
//前置通知
public class MyBeforeAdvise implements MethodBeforeAdvice {

    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("=============log==================");
    }
}
SomeService
package cn.happy.spring13aopadvisor;

/**
 * Created by Happy on 2017-07-30.
 */
public class SomeService implements ISomeService {
    //核心业务
    public void doSome(){
        System.out.println("我们都要找到Java开发工作，薪资6,7,8,9,10K");
    }

    public void add() {
        System.out.println("==============add============");
    }
}

applicationContextspring11advisor01.xml
<!--01.目标对象-->
    <bean id="someService" class="cn.happy.spring13aopadvisor.SomeService"></bean>

    <!--02.增强 通知-->
    <bean id="beforeAdvice" class="cn.happy.spring13aopadvisor.MyBeforeAdvise"></bean>

    <!--02.增强 :顾问Advisor：包装通知-->
    <bean id="beforeAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
        <property name="advice" ref="beforeAdvice" ></property>
        <property name="mappedNames" value="doSome2"></property>
    </bean>

    <!--03.aop -->
    <bean id="proxyService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--配置需要增强的目标对象-->
        <property name="target" ref="someService"></property>
        <!--做怎么样的增强-->
        <property name="interceptorNames" value="beforeAdvisor"></property>

    </bean>

测试
 @Test
    //名称匹配方法切入点顾问
    public void test01(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextspring11advisor01.xml");
        ISomeService service = (ISomeService) ctx.getBean("proxyService");
        service.doSome();
        service.add();
    }
正则表达式匹配方法切入点顾问
spring14aopadvisor02regex
ISomeService接口
package cn.happy.spring14aopadvisor02regex;

/**
 * Created by Happy on 2017-07-30.
 */
public interface ISomeService {
    public void doSome();
    public void add();
}
MyBeforeAdvise
package cn.happy.spring14aopadvisor02regex;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * Created by Happy on 2017-07-30.
 */
//前置通知
public class MyBeforeAdvise implements MethodBeforeAdvice {

    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("=============log==================");
    }
}

SomeService
package cn.happy.spring14aopadvisor02regex;

/**
 * Created by Happy on 2017-07-30.
 */
public class SomeService implements ISomeService {
    //核心业务
    public void doSome(){
        System.out.println("我们都要找到Java开发工作，薪资6,7,8,9,10K");
    }

    public void add() {
        System.out.println("==============add============");
    }
}

applicationContextspring12advisor02.xml
 <!--01.目标对象-->
    <bean id="someService" class="cn.happy.spring14aopadvisor02regex.SomeService"></bean>

    <!--02.增强 通知-->
    <bean id="beforeAdvice" class="cn.happy.spring14aopadvisor02regex.MyBeforeAdvise"></bean>

    <!--增强 顾问-->
    <bean id="beforeAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="beforeAdvice"></property>
        <property name="pattern" value=".*d.*" ></property>
    </bean>
    <!--03.aop -->
    <bean id="proxyService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--配置需要增强的目标对象-->
        <property name="target" ref="someService"></property>

        <!--做怎么样的增强-->
        <property name="interceptorNames" value="beforeAdvisor"></property>

    </bean>

测试
 @Test
    //正则表达式匹配方法切入点顾问
    public void test02(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextspring12advisor02.xml");
        ISomeService service = (ISomeService) ctx.getBean("proxyService");
        service.doSome();
        service.add();
    }

默认Advisor自动代理生成器
spring15aopauto01包

ISomeService接口
package cn.happy.spring15aopauto01;

/**
 * Created by Happy on 2017-07-30.
 */
public interface ISomeService {
    public void doSome();
    public void add();
}
MyAfterReturningAdvice
package cn.happy.spring15aopauto01;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

/**
 * Created by Happy on 2017-07-30.
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("===========after================");
    }
}

MyBeforeAdvise
package cn.happy.spring15aopauto01;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * Created by Happy on 2017-07-30.
 */
//前置通知
public class MyBeforeAdvise implements MethodBeforeAdvice {

    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("=============log==================");
    }
}
SomeService
package cn.happy.spring15aopauto01;

/**
 * Created by Happy on 2017-07-30.
 */
public class SomeService implements ISomeService {
    //核心业务
    public void doSome(){
        System.out.println("我们都要找到Java开发工作，薪资6,7,8,9,10K");
    }

    public void add() {
        System.out.println("==============add============");
    }
}
applicationContextspring13auto01.xml
<!--01.目标对象-->
    <bean id="someService" class="cn.happy.spring15aopauto01.SomeService"></bean>

    <!--02.增强 通知-->
    <bean id="beforeAdvice" class="cn.happy.spring15aopauto01.MyBeforeAdvise"></bean>
    <bean id="afterAdvice" class="cn.happy.spring15aopauto01.MyAfterReturningAdvice"></bean>
  <!--增强：前置顾问-->
    <bean id="beforeAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="beforeAdvice"></property>
        <property name="pattern" value=".*do.*"></property>
    </bean>

    <!--增强：后置顾问-->
    <bean id="afterAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="afterAdvice"></property>
        <property name="pattern" value=".*do.*"></property>
    </bean>

    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>

测试
@Test
    // 03.默认Advisor自动代理生成器
    public void test03(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextspring13auto01.xml");
        ISomeService service = (ISomeService) ctx.getBean("someService");
        service.doSome();
        service.add();
    }
BeanName自动代理生成器
spring16aopbeannameaop包
ISomeService接口
package cn.happy.spring16aopbeannameaop;

/**
 * Created by Happy on 2017-07-30.
 */
public interface ISomeService {
    public void doSome();
    public void add();
}
MyBeforeAdvise

package cn.happy.spring16aopbeannameaop;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * Created by Happy on 2017-07-30.
 */
//前置通知
public class MyBeforeAdvise implements MethodBeforeAdvice {

    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("=============log==================");
    }
}
SomeService
package cn.happy.spring16aopbeannameaop;

/**
 * Created by Happy on 2017-07-30.
 */
public class SomeService implements ISomeService {
    //核心业务
    public void doSome(){
        System.out.println("我们都要找到Java开发工作，薪资6,7,8,9,10K");
    }

    public void add() {
        System.out.println("==============add============");
    }
}
applicationContextspring14auto02.xml
 <!--01.目标对象-->
    <bean id="someService" class="cn.happy.spring16aopbeannameaop.SomeService"></bean>

    <!--02.增强 通知-->
    <bean id="beforeAdvice" class="cn.happy.spring16aopbeannameaop.MyBeforeAdvise"></bean>

    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <!--目标对象-->
        <property name="beanNames" value="someService"></property>
        <property name="interceptorNames" value="beforeAdvice"></property>
    </bean>

测试
@Test
    // BeanName自动代理生成器
    public void test04(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextspring14auto02.xml");
        ISomeService service = (ISomeService) ctx.getBean("someService");
        service.doSome();
        service.add();
    }
aspectj 注解
spring17aspectj包

ISomeService接口
package cn.happy.spring17aspectj;

/**
 * Created by Happy on 2017-07-30.
 */
public interface ISomeService {
    public void doSome();
    public String add();
}

MyAspect
package cn.happy.spring17aspectj;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * Created by Happy on 2017-07-31.
 */
@Aspect
public class MyAspect {

    //前置增强
    //@Before(value = "execution(* *..spring17aspectj.*.*(..))")
    public void myBefore(){
        System.out.println("===我是前置增强内容======");
    }
    //后置增强
    //@AfterReturning(value = "execution(* *..spring17aspectj.*.*(..))")
    public void myAferReturing(){
        System.out.println("===我是after内容======");
    }

    //环绕增强
    @Around(value = "execution(* *..spring17aspectj.*.*(..))")
    public Object myAround(ProceedingJoinPoint proceed) throws Throwable {
        System.out.println("===我是环绕前内容======");
        Object result = proceed.proceed();
        System.out.println("===我是环绕后内容======");
        if (result!=null){
            String str=(String)result;
            return str.toUpperCase();
        }else{
            return null;
        }
    }
}

SomeService
package cn.happy.spring17aspectj;

/**
 * Created by Happy on 2017-07-30.
 */
public class SomeService implements ISomeService {
    //核心业务
    public void doSome(){
        System.out.println("北京海淀区五道口");
    }

    public String add() {
        System.out.println("==============add============");
        return "add";
    }
}
applicationContextspring15aspect.xml
<!--01.目标对象-->
    <bean id="someService" class="cn.happy.spring17aspectj.SomeService"></bean>

    <!--02.增强 通知-->
    <bean class="cn.happy.spring17aspectj.MyAspect"></bean>

    <aop:aspectj-autoproxy/>
测试
@Test
    //aspectj 注解
    public void test05(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextspring15aspect.xml");
        ISomeService service = (ISomeService) ctx.getBean("someService");
        service.doSome();
        String result = service.add();
        System.out.println(result);
    }






















































                

        

        

    




    

      

        

            

              
                
                  子晴呀
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
qt qtableview动态代理

				
			

			

				

					09-14
				

			

		

		

			
				
通过动态代理，在单元格中添加spinbox，checkbox，combobox。

			
		

	



                

              
                



	

		

			

				
					
Java两种动态代理JDK动态代理和CGLIB动态代理

				
			

			

				

					学而不思则罔，思而不学则殆。--本博客多是本人的随手笔记，not for everybody。
				

				

					08-07
					
					14万+
					
				

			

		

		

			
				
目录

代理模式

JDK动态代理

cglib动态代理

测试

代理模式

代理模式是23种设计模式的一种，他是指一个对象A通过持有另一个对象B，可以具有B同样的行为的模式。为了对外开放协议，B往往实现了一个接口，A也会去实现接口。但是B是“真正”实现类，A则比较“虚”，他借用了B的方法去实现接口的方法。A虽然是“伪军”，但它可以增强B，在调用B的方法前后都做些其他的事情。Spring AOP...

			
		

	



                


  
              

                


	

		

			

				
					
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）

					
热门推荐

				
			

			

				

					aqin1012的博客
				

				

					02-23
					
					23万+
					
				

			

		

		

			
				
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？

			
		

	





	

		

			

				
					
动态代理详解

				
			

			

				

					白羊座的橙子
				

				

					10-08
					
					1万+
					
				

			

		

		

			
				
想要更加透彻的理解动态代理，首先要熟悉下静态代理。

			
		

	



		

			
		



	

		

			

				
					
java动态代理

				
			

			

				

					飞！！！的博客
				

				

					12-28
					
					5万+
					
				

			

		

		

			
				
前段时间去学习了一下RPC原理，其中提到了动态代理。特意去学习了一下，为了防止以后忘记，写下这篇博客做个记录，有不对的地方欢迎指正。
java中的常见的动态代理如Spring AOP。关于动态代理首先需要了解代理模式，根据代理类的创建时间又可以分为静态代理和动态代理。
1、代理模式
代理模式是常见的设计模式之一，Java我们通常通过new一个对象然后调用其对应的方法来访问我们需要的服务。代理模式则...

			
		

	





	

		

			

				
					
动态代理机制

				
			

			

				

					qq_49306008的博客
				

				

					12-12
					
					1904
					
				

			

		

		

			
				
文章目录代理模式1、使用代理模式的作用2、实现代理的方式3、静态代理
代理模式
代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之间起到中介的作用。
换句话说，使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑。
客户类真正想要访问的对象是目标对象，但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现的。代理类与目标类要实现同一个接口。
例如：有A，B，C三个类，A原

			
		

	





	

		

			

				
					
java + 动态代理 + 动态代理实际应用场景

				
			

			

				

					04-28
				

			

		

		

			
				
1：静态代理出现的实际背景，静态代理时如何演化成动态代理 2： 动态代理demo 举例实际应用场景（载入数据库驱动的时候，使用AIDL与系统Servic进行通信） 3: 动态代理使用到基础理论：ClassLoader 加载.class字节码...

			
		

	





	

		

			

				
					
动态代理由浅入深

				
			

			

				

					09-04
				

			

		

		

			
				
动态代理的作用：可以在不改变原有类的基础上对方法进行增强。执行代理对象的任何方法，就需要执行invocationHandler的invoke方法。本文对以上内容进行了举例分析。

			
		

	





	

		

			

				
					
动态代理例子

				
			

			

				

					05-17
				

			

		

		

			
				
是一个描述动态代理的实例，用的是反射的方法，感觉还是比较容易理解得

			
		

	





	

		

			

				
					
Lan仿朋友圈系统开源，可用于表白墙等微商相册，商品图册等.rar

				
			

			

				

					04-30
				

			

		

		

			
				
Lan仿朋友圈系统开源，可用于表白墙等微商相册，商品图册等.rarLan仿朋友圈系统开源，可用于表白墙等微商相册，商品图册等.rar

			
		

	





	

		

			

				
					
C++基础辅助类库.zip

				
			

			

				

					04-30
				

			

		

		

			
				
比如异步进行-Thread，安全句柄-CHandle，资源守卫-Guard，XML解析-rapidxml，以及其他注册表、文件基础操作。用于更加高效、安全的进行C++开发。温馨提示：至少需要支持C++0x标准的编译器。

			
		

	





	

		

			

				
					
集团企业IT技术架构规划方案qy.pptx

				
			

			

				

					04-30
				

			

		

		

			
				
集团企业IT技术架构规划方案qy.pptx

			
		

	





	

		

			

				
					
智能监控JAR进程：Bash脚本助力运维.zip

				
			

			

				

					04-30
				

			

		

		

			
				
本Bash脚本用于自动化管理Java JAR应用的启动、停止及监控。首先检查JAR进程是否在运行，如在运行则安全终止。随后，使用预设的Java参数启动JAR文件，并将输出和错误日志重定向至日志文件。启动后，脚本持续监控JAR进程状态，确保其在预设时间内成功启动。本脚本提供了灵活的配置和错误处理机制，为Java应用的运维管理带来了便捷与可靠性。

			
		

	





	

		

			

				
					
基于matlab价值认同的需求侧电能共享分布式交易策略源码+项目说明+详细注释.zip

				
			

			

				

					04-30
				

			

		

		

			
				
基于价值认同的需求侧电能共享分布式交易策略matlab源码+项目说明+详细注释.zip
# Supports_for_EPC
电力建设论文《基于价值认同的需求侧电能共享分布式交易策略》的支撑文件
————————————学术交流————————————————————
本论文提出了一种电能共享市场交易机制，利用一致性协议实现产消者之间关于价值的认同，实现了社会福利的最大化。
main_CA.m：针对10个产消者之间的电能共享，利用一致性算法完成市场的分布式出清
Pareto_analysis.m：通过两个产消者分析了电能共享市场的广义纳什均衡与市场效率。
运行环境：
MATLAB R2014a
YALMIP
GUROBI
需要注意的是：若程序运行错误，请认真检查是否安装了YALMIP和GUROBI求解器。
......

			
		

	





	

		

			

				
					
2024-2030全球及中国太阳能直流冰柜行业研究及十五五规划分析报告.docx

				
			

			

				

					04-30
				

			

		

		

			
				
2024-2030全球及中国太阳能直流冰柜行业研究及十五五规划分析报告

			
		

	





	

		

			

				
					
springcodespringcodespringcodespringcode

					
最新发布

				
			

			

				

					04-30
				

			

		

		

			
				
springcodespringcodespringcodespringcode

			
		

	





	

		

			

				
					
2023年前10大汽车用电流检测放大器企业占据全球86%的市场份额.docx

				
			

			

				

					04-30
				

			

		

		

			
				
2023年前10大汽车用电流检测放大器企业占据全球86%的市场份额

			
		

	





	

		

			

				
					
stm32单片机调试can总线上位机软件

				
			

			

				

					04-30
				

			

		

		

			
				
在STM32单片机上调试CAN总线并与其上位机通信时，需要遵循一系列的步骤和策略，以确保通信的可靠性和效率。以下是一些关键步骤和考虑因素：

硬件配置：确保STM32的CAN接口引脚正确连接到CAN收发器，并且CAN总线上的每个节点都通过120Ω的终端电阻正确终止。

波特率设置：所有CAN网络节点必须使用相同的波特率进行通信。波特率可以通过STM32的CAN外设的位时序寄存器(CAN_BTR)来设置。

初始化CAN外设：使用STM32的HAL库或标准库函数初始化CAN外设，包括设置工作模式、位时序、过滤器等。

过滤器配置：配置CAN过滤器以确定哪些消息ID可以被接收或发送。

中断配置：为了处理接收到的消息，通常需要配置CAN接收中断，并在中断服务例程(ISR)中处理消息。

发送和接收消息：实现CAN发送和接收消息的函数，使用HAL_CAN_Transmit_IT和HAL_CAN_Receive_IT等函数进行异步通信。

错误处理：实现错误处理机制，以应对可能的通信错误，如消息冲突、总线错误等。

回环测试：在只有一个STM32板的情况下，可以使用CAN的回环模式进行测试，以

			
		

	





	

		

			

				
					
spring 动态代理

				
			

			

				

					10-12
				

			

		

		

			
				
Spring 动态代理是 Spring 框架中的一个重要特性，它可以在运行时动态地生成代理类，从而实现对目标对象的代理操作。Spring 动态代理主要有两种方式：JDK 动态代理和 CGLIB 动态代理。  JDK 动态代理是基于接口的...

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值