精华内容
参与话题
问答
  • 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代理机制

    2019-10-08 04:06:32
    JDK代理 静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。动态代理:在程序运行时,运用反射机制动态创建而成。 JDK代理的是接口 JDK的动态代理...

    JDK代理

    静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。
    动态代理:在程序运行时,运用反射机制动态创建而成。

    JDK代理的是接口

    JDK的动态代理依靠接口实现,如果有些类并没有实现接口,则不能使用JDK代理,这就要使用cglib动态代理了

    接口BookFacade 

    public interface BookDao {
        public void addBook();
    }

    实现接口类

    public class BookDaoImpl implements BookDao {
        
        public void addBook() {
            System.out.println("增加图书方法。。。");
        }
    
    }

     代理类

    /**
     * JDK动态代理代理类 
     * 静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。
     * 动态代理:在程序运行时,运用反射机制动态创建而成。
     * @author wwl
     *
     */
    public class BookIntercept implements InvocationHandler {
        private Object target;
    
        public void setTarget(Object target) {
            this.target = target;
        }
    
        /**
         * 绑定委托对象并返回一个代理类
         * 
         * @param target
         * @return
         */
        public Object bind(Object target) {
            this.target = target;
            // 取得代理对象
            /**
             * ClassLoader loader:类加载器 
             * Class<?>[] interfaces:得到全部的接口 
             * InvocationHandler h:得到InvocationHandler接口的子类实例 
             */
            return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(), this); // 要绑定接口(这是一个缺陷,cglib弥补了这一缺陷)
        }
    
        /**
         * 回调方法
         * Object proxy:指被代理的对象。 
         * Method method:要调用的方法 
         * Object[] args:方法调用时所需要的参数 
         */
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            Object result = null;
            System.out.println("事物开始");
            // 执行方法
            result = method.invoke(target, args);
            System.out.println("事物结束");
            return result;
        }
    
    }

     

     调用:

         BookInterceptor bi = new BookInterceptor();//创建代理对象
            BookDao bookDao=new BookDaoImpl();
            bi.setTarget(bookDao);//设置代理目标对象
            BookDao bookProxy=(BookDao) Proxy.newProxyInstance(bookDao.getClass().getClassLoader(), bookDao.getClass().getInterfaces(), bi);
            bookProxy.addBook();
            //或者
            BookDao bookProxy1 = (BookDao) proxy.bind(new BookDaoImpl());
            bookProxy1.addBook();

     总结:其实代理对象bookProxy是实现BookFacade接口的对象,其可以直接执行接口中方法,当执行其中的方法时,方法会通过proxy调用invoke方法执行,

     

    当再每次执行某些方法时,进行执行特定操作时,应该如何实现?

    1、通过实现原接口,进行重写方法,但如果有很多地方则不可行

    2、通过继承原接口实现类,在方法中添加并通过super调用原实现类,需避免继承,如果一个对象需要包含多个原接口实现类的功能则不可以

    3、通过组合模式(一般通过组合代替继承),注入多个原接口实现类到对象中,不灵活

    4、动态代理,注意必须是接口

    转载于:https://www.cnblogs.com/atwanli/articles/4793399.html

    展开全文
  • 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...
  • 在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代理之二

    2019-08-22 16:41:30
    1.代理模式学习了三种:静态代理,JDK代理和cglib代理。 2.静态代理比较容易理解,代理类和目标类都需要实现接口。 3.有时也可将JDK代理和cglib代理统称为动态代理。动态代理不需实现接口。 接下来通过一...
  • 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是生成一个子类,覆盖其中的方法。 ...
  • 一、代理模式 代理模式就是为某个对象Q,提供一个代理对象,通过代理对象,...在SpringAOP的实现中,使用的核心技术就是动态代理,使用了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
收藏数 16,795
精华内容 6,718
关键字:

jdk代理