精华内容
下载资源
问答
  • jdk代理

    2017-11-03 17:59:40
    jdk代理

    jdk代理

        解释:程序在运行过程中,根据被代理的接口来动态生成代理类的class文件,并且加载运行。
        JDK提供了java.lang.reflect.Proxy类来实现动态代理的,可通过它的newProxyInstance来获得代理实现类。
    1:自定义接口
    package javabase.allinterface;
    
    public interface SaySimple {
        
        void sayHelloForSomeone(String name);
        
    }
    2:接口实现类
    package javabase.allimpl;
    
    import javabase.allinterface.SaySimple;
    
    public class SaySimpleImpl01 implements SaySimple{
    
        @Override
        public void sayHelloForSomeone(String name) {
            System.out.println("Hello!"+name);
        }
    
    }
    3:自定义实现InvocationHandler接口的类
    package javabase;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    public class ImplInvocationHandler implements InvocationHandler {
        
        private Object targetObj;
        
        public ImplInvocationHandler(Object obj) {
            this.targetObj = obj;
        }
        
        /**
         * @return
         * GY
         * 2017年11月6日
         */
        public Object getProxy(){
            return java.lang.reflect.Proxy.newProxyInstance(targetObj.getClass().getClassLoader(), 
                    targetObj.getClass().getInterfaces(), 
                    new ImplInvocationHandler(targetObj));
        }
    
        /*
         * 
         * 
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Before invocation");
            Object retVal = method.invoke(targetObj, args);
            System.out.println("After invocation");
            return retVal; 
        }
    
    }
    
    4:测试,用代理对象执行被代理接口实现类的方法
    package javabase;
    
    import java.lang.reflect.Proxy;
    
    import javabase.allimpl.SaySimpleImpl01;
    import javabase.allinterface.SaySimple;
    
    public class TestOfInvocationHandler {
    
        public static void main(String[] args) {
            SaySimple s = new SaySimpleImpl01();
            ImplInvocationHandler handle = new ImplInvocationHandler(s);
            
            SaySimple proxy = (SaySimple)Proxy.newProxyInstance(//TestOfInvocationHandler.class.getClassLoader(), 
                                                                handle.getClass().getClassLoader(),
                                                                //new Class[]{SaySimple.class},
                                                                s.getClass().getInterfaces(),
                                                                handle);
            proxy.sayHelloForSomeone("GY");
            
            SaySimple proxy2 = (SaySimple)handle.getProxy();
            proxy2.sayHelloForSomeone("WX");
        }
    
    }
    




    展开全文
  • JDK代理

    2019-09-19 23:57:11
    package com.java.proxy.jdk; public interface Student { public void addStudent (); } package com.java.proxy.jdk; public class StudentImpl imple...
    package com.java.proxy.jdk;
    
    public interface Student {
    	public void addStudent ();
    }
    
    
    package com.java.proxy.jdk;
    
    public class StudentImpl implements StudentDao{
    
    	public void addStudent () {
    		System.out.println("正在插入学生信息...");
    	}
    	
    }
    
    
    
    package com.java.proxy.jdk;
    
    
    
    public class JDKProxy {
    	public static void main(String[] args) {
    		//1.创建一个对象
    		StudentDao dao = new StudentImpl();
    		dao.add();
        //此处输出:正在插入学生信息...
    	}
    }
    
    但是我们这里血药用到jdk的动态代理:
    
    代码如下:
    package com.java.proxy.jdk;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    // JDK是对对象做代理
    public class JDKProxy implements InvocationHandler{
    	
    	private StudentDao  studentDao;  //定义一个全局变量方便后面用到
    
    	//定义一个方法用于创建JDK代理对象
    	//JDK代理是对对象做代理
    	public StudentDaocreateProxyObject(StudentDao  studentDao){
    		//被代理对象作为参数传入进来
    		this.studentDao= studentDao; 
    		//获取类加载器:对谁做代理,使用谁的类加载器
    		ClassLoader loader = studentDao.getClass().getClassLoader();
    		//获取被代理对象的所有实现接口
    		Class<?>[] interfaces = studentDao.getClass().getInterfaces();
    		//创建Handler对象
    		InvocationHandler h = this;
    		Object proxyObject = Proxy.newProxyInstance(loader, interfaces, h); //创建代理对象
    		return (StudentDao) proxyObject;
    	}
    
    	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
        //这里面可以写一些你需要增强的代码
    		System.out.println("正在连接数据库");
    		//对原始操作进行调用(反射)
    		method.invoke(studentDao, args);
    		System.out.println("开始关闭数据库");
    		return null;
    	}
    	
    	public static void main(String[] args) {
    		//1.创建一个对象
    		UserDao dao = new UserImpl();
    		//2.为原始对象创建代理对象
    		UserDao daoProxy = new JDKProxy().createProxyObject(dao);  //其中这里面穿的是个对象
    		//3.使用代理对象运行操作
    		daoProxy.add();
    		
    /**
    *  运行结果 :正在连接数据库
                正在插入学生信息...
                开始关闭数据库
    *
    *
    /
    	}
    }
    

    希望对你们有帮助,自己也在学习这个,分享下。

    转载于:https://my.oschina.net/791076963/blog/904144

    展开全文
  • JDK代理和Cglib代理

    2013-11-20 14:54:55
    JDK代理和Cglib代理,下载源码清楚了解二者区别
  • Java JDK代理与CGLIB代理

    2019-07-17 20:29:42
    Java JDK代理与CGLIB代理区别 1、JDK代理与CGLIB代理程序结构

    Java JDK代理与CGLIB代理区别

    1、JDK代理与CGLIB代理程序结构

    展开全文
  • 2、静态代理与JDK代理对比 1、使用 JDK 代理 使用 JDK 代理完成上一章 静态代理的事务管理的功能。 沿用上一章的几个类: 实体类:User 接口:UserService 接口实现类: UserServiceImpl 编写JDK 工厂代理类:...

    目录

     

    1、使用 JDK 代理

    2、静态代理与JDK代理对比


    1、使用 JDK 代理

    使用 JDK 代理完成上一章 静态代理的事务管理的功能。

    沿用上一章的几个类:

    • 实体类:User
    • 接口:UserService
    • 接口实现类: UserServiceImpl

    编写JDK 工厂代理类:

    package com.lcy.proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * 基于 JDK 的动态代理工厂
     */
    public class ProxyFactory implements InvocationHandler {
        // 1 持有一个目标对象(被代理对象)
        private Object target;
        
        public ProxyFactory(){}
        // 2 注入目标对象
        public ProxyFactory(Object target){
            this.target = target;
        }
        
        // 3 生成代理对象,使用的是反射技术
        public <T> T getProxy() {
            return (T)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        }
    
        // 4 代理对象执行的方法
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("使用JDK动态代理----开启事务");
            // 5 调用 目标对象的执行方法
            Object result = method.invoke(target, args);
            System.out.println("使用JDK动态代理----提交事务");
            return result;
        }
    }
    

    测试方法:

    package com.lcy.test;
    
    import com.lcy.model.User;
    import com.lcy.proxy.ProxyFactory;
    import com.lcy.service.UserService;
    import com.lcy.service.impl.UserServiceImpl;
    
    public class ProxyFactoryTest {
    
        public static void main(String[] args) {
            UserService userService = new UserServiceImpl();
            ProxyFactory proxy = new ProxyFactory(userService);
            UserService userServiceProxy = (UserService)proxy.getProxy();
            userServiceProxy.save(new User(3, "张无忌"));
        }
    
    }
    

    程序运行结果:

    2、静态代理与JDK代理对比

    静态代理:

    1、必须实现目标对象接口。如果有多个对象需要代理(相同功能),那就需要给每个对象都定义多个代理的类。比如说 UserService -> UserServiceImplProxy ,DeptService -> DeptServiceImplProxy

    UserServiceImplProxy 、DeptServiceImplProxy 这些代理类做的事情都一样,都是开启事务和提交事务。这样会导致系统中会有很多功能一样的代理类

    2、一旦目标对象接口发生改变,静态代理的代理类也要跟着修改。比如说 UserService 接口中新增了remove 方法,在 UserServiceImplProxy 代理类中也要现在 remove 方法

    JDK 代理:

    1、不需要实现目标接口。可以为任意类进行代理。比如说:为 UserService 接口代理,只需要在创建代理类的时候,注入 UserService 接口的实现。然后利用 java反射技术动态生成代理类对象。

    2、一旦目标对象接口发生改变,动态代理的代理类无需修改。比如说: UserService 接口新增了 remove 方法,ProxyFactory 代理工厂无需修改。

     

     

    展开全文
  • 1.JDK代理只能针对有接口的类的接口方法进行动态代理 2.JDK代理也不能对private方法进行动态代理 2.Cglib基于继承来实现代理,无法对static、final类进行代理 3.Cglib由于基于继承实现代理,无法对private、...
  • JDK代理实现

    2018-12-23 00:34:20
    一、写在前面 JDK代理基于接口的动态代理,使用JDK 官方的 Proxy 类,要求被代理类最少实现一个接口。
  • Java代理实践:静态代理、JDK代理、CGLIB代理
  • 1、JDK动态代理基于接口实现,所以实现JDK动态代理,必须先定义接口;CGLib动态代理基于被代理类实现; 2、JDK动态代理机制是委托机制,委托hanlder调用原始实现类方法;...xml中配置时默认是JDK代理,要开启CGLib...
  • Java之JDK代理

    2020-06-17 16:45:12
    1.java jdk 代理 核心 jdk 代理基于 : InvocationHandler (接口) Proxy (代理类) 被代理类必须有抽象接口(父级) 2.代码如下 public interface Subject { void hello(String param); } public...
  • 文章目录一、JDK代理图解二、基于接口的JDK动态代理三、JDK代理演示(1)接口(2)目标类(3)事务类/拦截器(4)JDK代理类(5)日志类(5)安全校验类 一、JDK代理图解 二、基于接口的JDK动态代理 提供者:JDK 官方的 Proxy...
  • 概念:通过调用jdk的反射机制来实现代理操作,需要注意的是,如果要使用jdk代理,那么目标类是一定要实现被代理的接口的,所以jdk代理也被称为接口代理,课外话题:jdk代理与cglib代理的区别是,jdk代理一定要实现被...
  • 在AOP代理poxy配置时,有poxy-target-class来控制-值为false为JDK代理,为true为CGlib代理 在Spring中,常用的代理类一是使用GDK代理,二是使用CGlib代理,下面讲述两种代理的不同 二、代理区分 (1)JDK代理....
  • Java JDK代理、CGLIB、AspectJ代理分析比较
  • spring 默认创建的是JDK代理 创建JDK代理,我们需要做的: 1.配置自动代理——无论是创建CGLIB代理 JDK代理 都需要此配置 2.创建切面类,基于注解或配置都可,在这里采用基于配置的方式 切面类 配置 3....
  • JDK代理和CGLIB代理的区别 区别 JDK: java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。 CGKIB: cglib动态代理是利用asm开源包,对代理对象类的class文件加载...
  • Java的JDK代理

    2018-03-17 22:12:15
    写在前面: Spring框架AOP的核心就是动态代理,动态代理又分为JDK代理和Cglib代理,这篇博客先来总结JDK代理的方法。JDK代理的核心是反射。所以要想手动实现动态代理,必须要实现InvocationHandler接口,并且有...
  • JDK代理是什么 JDK动态代理是通过java.lang.reflect.Proxy类来实现的,我们可以调用Proxy了的newProxyInstance()方法来创建代理对象。对于使用业务接口的类,Spring默认会使用JDK动态代理来实现AOP....
  • jdk动态代理--利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理...对比:cglib代理比jdk代理快 ———————————————— 原文链接:https://blog.csdn.net/u0128900...
  • 编写服务类和接口,这个是真正的服务提供者,在JDK代理接口是必须的。 .编写代理类,提供绑定和代理方法。 JDK动态代理最大的缺点就是需要提供接口直接看例子:接口类:HelloService:p...
  • //JDK动态代理基于接口实现,所以实现JDK动态代理,必须先定义接口JDK代理与目标类没有关系 配置如下: application.xml文件中 <aop:aspectj-autoproxy proxy-target-class="false"/> Test: package ...
  • 拦截器 + jdk代理

    2018-08-11 11:14:38
    由于动态代理较难理解,可以设计一个拦截器来实现代理。只需要知道拦截器接口的方法、含义、... 这里的1建立关系还是在jdk代理类中实现,而2代理逻辑则是放在了拦截器实现类中,jdk代理类只是调用拦截器方法。 ...
  • jdk代理: cglib代理: jdk代理要求目标对象必须实现接口,原因:1,生成的代理对象继承了Proxy类,如果又要继承目标对象类的话不科学,java不支持多继承。故只能实现接口。  2,Proxy.newProxyInstance里...
  • Java动态代理--jdk代理

    2017-06-28 20:10:56
    Java动态代理为实例对象提供一个模仿者,这个模仿者不仅可以拥有真是类的行为,还可以自定义的添加一些内容;aop中大量的应用了动态代理机制。...jdk代理根据类的接口生成代理,因此jdk只能为实现了接口的类进行代理。
  • 这篇文章不对JDK代理和CGLIB代理的内部实现细节讲解,这只是简单提一下如何使用,以及代理技术在实际中的用处。 先说一下静态代理。 明确一个原则,写出的代码投入到生产中后,最好不要对代码再进行修改。 比如...
  • 面试中会遇见面试官:JDK代理与Spring cglib代理的区别:  简单的回答:  1,JDK只能代理接口,cglib代理的是类。  2,JDK射机制生成一个实现代理接口的匿名类,cglib是生成一个子类,覆盖其中的方法。 ...
  • Spring实现的AOP--JDK代理1.jdk代理实现AOP的原理2.例子2.1创建一个spring项目2.2创建Java文件2.3xml文件2.4运行结果3.总结 1.jdk代理实现AOP的原理 jdk代理: aop实现原理: 首先创建一个目标类–正常类 然后创建一...
  • JDK动态代理是java JDK自身提供的基于接口的代理,代理类的生成速度快,而...代理类的生成速度慢,而代理类的运行速度快,适合于singleton类型Spring通过判断目标类是否有实现接口来选择JDK代理和Cglib代理,如果...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,168
精华内容 7,667
关键字:

jdk代理