精华内容
下载资源
问答
  • Java动态生成类以及动态添加属性

    万次阅读 2017-11-18 16:14:20
    有个技术实现需求:动态生成类,其中类中的属性来自参数对象中的全部属性以及来自参数对象properties文件。 那么技术实现支持:使用CGLib代理。 具体的实现步骤: 1.配置Maven文件: xmlns:xsi=...

    有个技术实现需求:动态生成类,其中类中的属性来自参数对象中的全部属性以及来自参数对象properties文件。

    那么技术实现支持:使用CGLib代理。

    具体的实现步骤:

    1.配置Maven文件:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.journey</groupId>
        <artifactId>journey</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <dependency>
                <groupId>cglib</groupId>
                <artifactId>cglib</artifactId>
                <version>2.2.2</version>
            </dependency>
        </dependencies>
    
    </project>

    2.封装的cglib类

    package com.journey;
    
    import net.sf.cglib.beans.BeanGenerator;
    import net.sf.cglib.beans.BeanMap;
    
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * Created by little_eleventh_wolf on 2017/11/18.
     */
    public class DynamicBean {
        private Object object = null; //动态生成的类
        private BeanMap beanMap = null; //存放属性名称以及属性的类型
    
        public DynamicBean() {
            super();
        }
    
        public DynamicBean(Map propertyMap) {
            this.object = generateBean(propertyMap);
            this.beanMap = BeanMap.create(this.object);
        }
    
        /**
         * @param propertyMap
         * @return
         */
        private Object generateBean(Map propertyMap) {
            BeanGenerator generator = new BeanGenerator();
            Set keySet = propertyMap.keySet();
            for(Iterator i = keySet.iterator(); i.hasNext(); ) {
                String key = (String) i.next();
                generator.addProperty(key, (Class) propertyMap.get(key));
            }
            return generator.create();
        }
    
        /**
         * 给bean属性赋值
         * @param property 属性名
         * @param value 值
         */
        public void setValue(Object property, Object value) {
            beanMap.put(property, value);
        }
    
        /**
         * 通过属性名得到属性值
         * @param property 属性名
         * @return 值
         */
        public Object getValue(String property) {
            return beanMap.get(property);
        }
    
        /**
         * 得到该实体bean对象
         * @return
         */
        public Object getObject() {
            return this.object;
        }
    }

    3.需求的实现类:

    package com.journey;
    
    import java.beans.BeanInfo;
    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;
    import java.io.InputStream;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Properties;
    import java.util.Set;
    
    /**
     * Created by little_eleventh_wolf on 2017/11/18.
     */
    public class ClassUtil {
        private String filePath = "/config/"; //配置文件路径
    
        public String getFilePath() {
            return filePath;
        }
    
        public void setFilePath(String filePath) {
            this.filePath = filePath;
        }
    
        public Object dynamicClass(Object object) throws Exception {
            HashMap returnMap = new HashMap();
            HashMap typeMap = new HashMap();
            //读取配置文件
            Properties prop = new Properties();
            String sourcepackage = object.getClass().getName();
            String classname = sourcepackage.substring(sourcepackage.lastIndexOf(".") + 1);
            InputStream in = ClassUtil.class.getResourceAsStream(filePath + classname + ".properties");
            prop.load(in);
    
            Set<String> keylist = prop.stringPropertyNames();
    
            Class type = object.getClass();
            BeanInfo beanInfo = Introspector.getBeanInfo(type);
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for(int i = 0; i < propertyDescriptors.length; i++) {
                PropertyDescriptor descriptor = propertyDescriptors[i];
                String propertyName = descriptor.getName();
                if(!propertyName.equals("class")) {
                    Method readMethod = descriptor.getReadMethod();
                    Object result = readMethod.invoke(object, new Object[0]);
                    if(result != null) {
                        returnMap.put(propertyName, result);
                    } else {
                        returnMap.put(propertyName, "");
                    }
                    typeMap.put(propertyName, descriptor.getPropertyType());
                }
            }
            //加载配置文件中的属性
            Iterator<String> iterator = keylist.iterator();
            while(iterator.hasNext()) {
                String key = iterator.next();
                returnMap.put(key, prop.getProperty(key));
                typeMap.put(key, Class.forName("java.lang.String"));
            }
            //map转换成实体对象
            DynamicBean bean = new DynamicBean(typeMap);
            //赋值
            Set keys = typeMap.keySet();
            for(Iterator it = keys.iterator(); it.hasNext(); ) {
                String key = (String) it.next();
                bean.setValue(key, returnMap.get(key));
            }
            Object obj = bean.getObject();
            return obj;
        }
    
        public static void main(String[] args) throws Exception {
            new ClassUtil().dynamicClass(new LeapRole()/*LeapRole是个普通类,未贴源码*/);
        }
    }

    4.技术实现目的:前台框架表格数据源实际上就是带有数据的实体,但是grid中数据的类型、以及是否可见、toolbar工具栏上的按钮、是否分页,是针对实体而言,所以目前把这些信息作为实体的配置文件。在展示页面之前,读取全部信息,转为参数对象的完整对象。


    展开全文
  • 利用cglib库给对象动态添加属性

    千次阅读 2015-12-24 10:29:05
    他实现了动态给某个对象添加属性并设置值:但是并不是真正意义上的给属性动态添加属性,只是实现了这种效果而已; 应用场景:vo对象,当我们给vo对象赋值的时候可以采用这种方法,不需要每次都创建vo对象;用这个实现....
    package com.lrq.cglib;

    import java.util.Map;

    import net.sf.cglib.beans.BeanGenerator;
    import net.sf.cglib.beans.BeanMap;

    public class DynamicGenerateBean {

    private Object object;

    private BeanMap beanMap;

    public DynamicGenerateBean(Map<String, Class> propertyMap) {
    super();
    this.object = this.generateBean(propertyMap);
    this.beanMap = BeanMap.create(this.object);
    }

    private Object generateBean(Map<String, Class> propertyMap) {
    BeanGenerator beanGenerator = new BeanGenerator();
    for (Map.Entry<String, Class> me : propertyMap.entrySet()) {
    // 给bean添 属性;即属性对应的类型;
    beanGenerator.addProperty(me.getKey(), me.getValue());
    }
    return beanGenerator.create();
    }

    public void setPropertyByName(String propertyName, Object value) {
    this.beanMap.put(propertyName, value);
    }

    public Object getPropertyByName(String propertyName) {
    return this.beanMap.get(propertyName);
    }

    }

    测试类:
    package com.lrq.cglib;

    import java.util.HashMap;
    import java.util.Map;

    import org.junit.Test;

    public class DynamicGenerateBeanTest {
    @SuppressWarnings({ "unused", "rawtypes" })
    @Test
    public void test(){

    Map<String, Class> propertyMap=new HashMap<String, Class>();
    propertyMap.put("id", Integer.class);
    propertyMap.put("name", String.class);
    //propertyMap.put("",int.class);
    DynamicGenerateBean dynamicGenerateBean=new DynamicGenerateBean(propertyMap);
    dynamicGenerateBean.setPropertyByName("id", 1);
    dynamicGenerateBean.setPropertyByName("name", "lirongqiang");
    System.out.println(dynamicGenerateBean.getPropertyByName("id"));
    System.out.println(dynamicGenerateBean.getPropertyByName("name"));
    //System.out.println(dynamicGenerateBean.getPropertyByName("id"));
    }
    }

    他实现了动态给某个对象添加属性并设置值:但是并不是真正意义上的给属性动态添加属性,只是实现了这种效果而已;
    应用场景:vo对象,当我们给vo对象赋值的时候可以采用这种方法,不需要每次都创建vo对象;用这个实现.然后根据自己的业务逻辑改造
    这个类就行了
    <script type="text/javascript" id="wumiiRelatedItems"> </script>
     
    展开全文
  • 本博客将会介绍动态代理在Android应用中的对第三方SurfaceView进行镜像翻转中的应用。代理模式的作用是为其它对象提供一种代理以控制对这个对象的访问。比如用户调用了一个“吃饭”的方法,如果不依靠代理,用户可能...

    本博客将会介绍动态代理在Android应用中的一种使用场景

    代理模式

    代理模式的作用是为其它对象提供一种代理以控制对这个对象的访问。比如用户调用了一个“吃饭”的方法,如果不依靠代理,用户可能自己拿碗饭吃就行,而如果通过代理的话,可能连碗都不需要用户自己拿,用户只需要张开嘴,代理来喂就行了,需要注意的是,这里代理除了负责拿碗和喂饭外还可以做其他的任何事情,比如说帮你把饭吹凉一些,或者担心你的体重而偷偷帮你倒掉了一半的饭,又或者是往饭里加点什么奇奇怪怪的东西,谁知道呢,这就是代理干的活。实际上在java里面也提供了代理这一神奇的模式,而且还分为静态和动态两种,两者的区别是静态代理的结构在程序运行前就已经安排好了的,而动态代理则是在程序运行过程中指定的,本文所采用的就是动态代理方法。

    镜像翻转

    在之前的一篇博客【Android】android镜像翻转 中分析过如何对一个View进行镜像翻转,也就是实现如下的效果:

        

    镜像水平翻转前后效果

    对于一般的View而言,直接用view.setScaleY(-1)即可达到这样的效果,而且针对自定义SurfaceView,也可以使用

    canvas.scale(-1,1,canvas.getWidth()/2,canvas.getHeight()/2)

    来进行翻转。但是如果面对的是第三方SurfaceView,且无法直接获取到SurfaceView用于绘制的canvas对象的话。比如上面左图实现代码如下。

    public class TestSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
    
        public TestSurfaceView(Context context, AttributeSet attrs) {
            super(context, attrs);
            getHolder().addCallback(this);
        }
    
        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            // 获取canvas
            Canvas canvas = holder.lockCanvas();
    
            canvas.drawColor(Color.rgb(220,220,220));
            Paint paint = new Paint();
    
            paint.setTextSize(60);
    
            // 绘制文字
            canvas.drawText("Hello, this is SurfaceView",200,600,paint);
            // 绘制圆
            canvas.drawCircle(300,800,100,paint);
    
            // 显示
            holder.unlockCanvasAndPost(canvas);
        }
    
        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {}
    
        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {}
    }

    假设TestSurfaceView在第三方Jar包中,且无法对其进行修改。那么该如何对这个界面进行镜像翻转呢,下面给出通过动态代理实现的方案

    源码分析

    结合上面的代码,我们知道,SurfaceView的绘制过程如下:


    SurfaceView绘制流程

    通常调用代码如下:

    // 获取canvas画布
    Canvas canvas = holder.lockCanvas();
    //绘制内容
    ... ...
    
    // 解锁画布,显示画布内容
    holder.unlockCanvasAndPost(canvas);
    holder是什么呢,我们可以在SurfaceView的源码里找到SurfaceHolder的实例mSurfaceHolder以及实现。

    public class SurfaceView extends View {
    ......
        private final SurfaceHolder mSurfaceHolder = new SurfaceHolder() {
    
            private static final String LOG_TAG = "SurfaceHolder";
    
            @Override
            public boolean isCreating() {
                return mIsCreating;
            }
    
            ......
    
            @Override
            public Canvas lockCanvas() {
                return internalLockCanvas(null);
            }
    
            @Override
            public Canvas lockCanvas(Rect inOutDirty) {
                return internalLockCanvas(inOutDirty);
            }
    
            ......
    
        };
    }

    在源码里,我们可以看到mSurfaceHolder里实现了lockCanvas方法,并且返回了Canvas,这里就是突破口。

    代理实现

    代理的目标是要实现对surfaceholder里的lockCanvas方法进行监控,并为其返回值添加一定的操作,也就是将原先的流程改为如下结构:


    动态代理添加访问控制

    首先需要实现的是代理处理器,其代码如下:

    public class TestInvocation implements InvocationHandler {
        Object mObject ;
    
        public TestInvocation(Object object) {
            mObject = object;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 截取lockCanvas方法调用
            if ("lockCanvas".equals(method.getName())) {
                // lockCanvas方法返回值是canvas画布
                Canvas canvas = (Canvas) method.invoke(mObject,args);
                // 添加镜像
                canvas.scale(-1,1,canvas.getWidth()/2,canvas.getHeight()/2);
    
                return canvas;
            }
            return method.invoke(mObject,args);
        }
    }
    

    代理处理器做的是在invoke的地方将lockCanvas方法过滤了出来,然后执行lockCanvas方法,并获返回值,这个返回值就是canvas对象,这个canvas是SurfaceView将要在上面作画的画布,所以这里我们可以通过代理事先为其添加镜像翻转的效果,添加完成之后之后返回给正常流程来继续执行。

    完成代理处理器之后就可以为surfaceHolder添加动态代理,这里需要注意的是surfaceHolder在SurfaceView中,所需先取出来,再为之添加代理,代码如下:

    // 获取 surfaceView中的 surfaceHolder
    SurfaceHolder mSurfaceHolder = mTestSurfaceView.getHolder();
    // 创建代理接口的实现
    TestInvocation testInvocation = new TestInvocation(mSurfaceHolder);
    // 为 mSurfaceHolder 添加动态代理,并获取添加代理之后的 newSurfaceHolder
    SurfaceHolder newSurfaceHolder = (SurfaceHolder) Proxy.newProxyInstance(mSurfaceHolder.getClass().getClassLoader(),mSurfaceHolder.getClass().getInterfaces(),testInvocation);
    
    新生成的newSurfaceHolder就是已经添加上动态代理的surfaceHolder,因为在SurfaceView中SurfaceHolder是私有属性,无法直接替换,所以这里需要借助反射机制来讲newSurfaceHolder替换掉SurfaceView中原先的mSurfaceHolder,代码如下:

    // 获取mSurfaceHolder的field
    Field fieldHolder = SurfaceView.class.getDeclaredField("mSurfaceHolder");
    // 更改为可访问权限
    fieldHolder.setAccessible(true);
    // 用添加代理后的 newSurfaceHolder 替换 mSurfaceHolder
    fieldHolder.set(mTestSurfaceView,newSurfaceHolder);

    添加动态代理之后,TestSurfaceView中调用holder的lockCanvas方法所获取到的canvas都是经过TestInvocation转置的canvas,从而实现了这个奇怪的需求,也就是实现右侧图片的效果。


    源码下载

    整个工程的源码如下

    Android动态代理实践


    展开全文
  • Java动态代理在一些中间件中经常用到,或者一些大型项目中都会用到。 这里顺带使用一下自定义注解方式,基于java 反射机制读取.properties格式文件。 demo的大致内容包含以下: 1.配置文件:config.properties url=...

    Java动态代理在一些中间件中经常用到,或者一些大型项目中都会用到。
    这里顺带使用一下自定义注解方式,基于java 反射机制读取.properties格式文件。

    demo的大致内容包含以下:
    在这里插入图片描述

    1.配置文件:config.properties

    url=http://www.hrsstd.com
    password= root
    username= zhanghuilong
    port = 8080
    isOpen = true
    
    

    2.自定义注解类

    注解中的原生标签具体含义可以自行了解

    /**
     * @author zhanghuilong
     * @desc 自定义注解,读取配置文件内容
     * @since 2019/01/02
     */
    @Target({ ElementType.FIELD, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface ReadConf {
        /**
         * read config.properties context eg: key = value
         * @return
         */
        String value();
    
    }
    

    3.demo接口定义

    /**
     * @author zhanghuilong
     * @desc  配置中心
     * @since 2019/01/02
     */
    public interface HrsConfigService {
    
        @ReadConf(value = "url")
        String  getUrl();
    
        @ReadConf("password")
        String getPwd();
    
        @ReadConf("username")
        String getUserName();
    
        @ReadConf("port")
        Integer getPort();
    
        @ReadConf("isOpen")
        Boolean getOff();
    }
    

    4.动态代理核心实现
    invocationHandler的实现

    
    /**
     * @author zhanghuilong
     * @desc 动态代理具体实现方法
     * @since 2019/01/02
     */
    public class PropertyInvocationHandler implements InvocationHandler {
    
        private Properties properties;
    
        public PropertyInvocationHandler(Properties properties) {
            this.properties = properties;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
            System.out.println(" 调用 method = [" + method.getName() +"]");
            ReadConf readConf = method.getAnnotation(ReadConf.class);
            if (readConf == null){
                return null;
            }
            String value = readConf.value();
            String property = properties.getProperty(value);
            if (StringUtils.isEmpty(property)){
                return null;
            }
    
            Class<?> returnClass = method.getReturnType();
            // 基本原始类型,这里只写了部分类型,满足当前demo接口返回值类型,如遇项目有多重类型,可以添加补全所以类型
            if (returnClass.isPrimitive()){
                if (returnClass.equals(int.class)){
                    return Integer.valueOf(property);
                }
                else if (returnClass.equals(long.class)){ return (Long.valueOf(property));}
                else if (returnClass.equals(double.class)) {return (Double.valueOf(property));}
                else if (returnClass.equals(float.class)) { return (Float.valueOf(property)); }
                else if (returnClass.equals(boolean.class)) { return (Boolean.valueOf(property));}
            }else {
                if (returnClass.equals(Integer.class)){
                    return Integer.valueOf(property);
                }else if (returnClass.equals(String.class)){
                    return String.valueOf(property);
                }else if (returnClass.equals(Boolean.class)){
                    return Boolean.valueOf(property);
                }
            }
    
            return property;
        }
    }
    
    

    5.读取配置的通用工厂方法

    /**
     * @author zhanghuilong
     * @desc 读取配置工厂方法
     * @since 2019/01/02
     */
    public class HrsConfigFactory {
    
        public HrsConfigFactory() {
        }
    
        /**
         * 读取方法
         * @param inputStream
         * @return
         */
        public static HrsConfigService readProperties(final InputStream inputStream){
    
            final Properties properties = new Properties();
            try {
                properties.load(inputStream);
            } catch (IOException e) {
                System.out.println("load inputStream error ");
                return null;
            }
            
            // java 代理机制
            return  (HrsConfigService)Proxy
                .newProxyInstance(HrsConfigService.class.getClassLoader(), new Class[] { HrsConfigService.class },
                    new PropertyInvocationHandler(properties));
        }
    }
    
    

    6.demo 的测试执行类main方法

    /**
     * @author zhanghuilong
     * @desc 动态代理+自定义注解
     * @since 2019/01/02
     */
    public class DemoTest {
    
        public static void main(String[] args) {
    
        try {
            // 文件地址可以直接copypath
            InputStream fileInputStream = new FileInputStream("/Users/zhanghuilong/demo/config.properties");
            HrsConfigService configService = HrsConfigFactory.readProperties(fileInputStream);
            if (configService == null){
                return;
            }
            Integer port = configService.getPort();
            String url = configService.getUrl();
            String userName = configService.getUserName();
            String pwd = configService.getPwd();
            Boolean off = configService.getOff();
            String format = String.format("读取配置信息,url: %s, username: %s, password: %s, port :%s, 开关:%s",
                url, userName, pwd, port, off);
    
            System.out.println( format );
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在");
        }
    
        }
    }
    
    

    输出:

     调用 method = [getPort]
     调用 method = [getUrl]
     调用 method = [getUserName]
     调用 method = [getPwd]
     调用 method = [getOff]
    读取配置信息,url: http://www.hrsstd.com, username: zhanghuilong, password: root, port :8080, 开关:true
    

    本文主要想简单说明下 java 动态代理在实际工作中的应用 和实践。

    展开全文
  • 秒懂Java代理动态代理模式

    万次阅读 多人点赞 2018-06-30 17:08:23
    什么是动态代理模式?二者什么关系?具体如何实现?什么原理?如何改进?这即为我们学习一项新知识的正确打开方式,我们接下来会以此展开,让你秒懂。 概念 什么是代理模式 定义:为其他对象提供一种代理以控制...
  • 代理模式(Proxy Pattern)是一种结构性模式。代理模式为一个对象提供了一个替身,以控制对这个对象的访问。即通过代理对象访问目标目标对象,可以在目标对象实现的基础上,增强额外的功能操作...动态代理 cglib代理 应用
  • 实现原理类似于JDK的动态代理,只是它在运行期间生成目标类扩展的子类对象.(也就是通过继承的方式创建的代理类).CGLIB是高效的代码生成包,底层是依靠ASM(开源的Java字节码编辑类库)操字节码实现的,性能比JDK强. ...
  • 静态代理动态代理简介

    千次阅读 2017-07-14 15:49:19
    代理对象可以在客户端和目标对象之间起到中介的作用,并且可以通过代理对象去掉客户不能看到的内容和服务或者添加客户需要的额外服务。 代理模式的角色分为: 主题接口: 即代理类的所实现的行为接口
  • 很多时候我们需要监听动态添加的元素事件。 举个例子: 页面中有一个div,div中有一个button以及一个table,我们需要在点击button的时候相应的table行进行排序,而根据特定需求ajax返回数据中的table值是变化的, ...
  • 1.JDK动态代理当一个对象(客户端)不能或者不想直接引用另一个对象(目标对象),这时可以应用代理模式在这两者之间构建一个桥梁--代理对象,此代理对象和目标对象实现了相同的接口,目标对象作为代理对象的一个...
  • 什么是动态代理?想很好的了解动态代理,就需先来了解代理的概念,代理 (Proxy)这个概念在现实生活中无处不在,比如房屋中介,它就是一个代理对象, 能代理行驶房东(可以理解为Target)的权力,除此之外中介可以...
  • 深入剖析JDK动态代理实现原理

    千次阅读 2018-01-21 17:35:20
    比如说有一个业务需要我们在添加或者删除用户的时候,将信息添加到日志当中,但是把日志的代码插入原有的业务代码中是很不雅观的,为了不破坏原有的实现类,这时候我们就可以用到动态代理。 接口类 public ...
  • Java笔试面试-反射和动态代理

    万次阅读 多人点赞 2019-09-19 09:28:41
    简单来说就是通过反射,可以在运行期间获取、检测和调用对象的属性和方法。 反射的使用场景 1.编程工具 IDEA 或 Eclipse 等,在写代码时会有代码(属性或方法名)提示,就是因为使用了反射; 2.很多知名的框架,为了...
  • Java 使用动态代理动态修改注解值

    万次阅读 2017-11-02 09:32:17
    java 中定义注解都是在编写...这里需要用到的是Proxy 动态代理第一步得到代理实例:InvocationHandler invocationHandler = Proxy.getInvocationHandler(componentScan);然后再通过代理示例来操作注解上的值: Invocat
  • java反射和动态代理详解

    千次阅读 2017-09-29 09:50:05
    动态代理 反射
  • Java代理动态代理机制分析和应用

    千次阅读 2015-12-02 19:54:54
    本博文中项目代码已开源下载地址:GitHubJava代理动态代理机制分析和应用概述代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息,过滤消息并转发...
  • 动态代理织入,在运行期为目标类添加通知生成子类的方式。Spring AOP框架默认采用动态代理织入,而AspectJ(基于Java语言的AOP框架)采用编译器织入和类装载期织入。就是将原来的方法,与其它类的方法一起调用 3. ...
  • 给分类(Category)添加属性

    千次阅读 2015-07-07 17:37:55
    给分类(Category)添加属性 字数626 阅读513 评论1 喜欢17 遇到一个问题,写了一个分类,但原先类的属性不够用。添加一个属性,调用的时候崩溃了,说是找不到getter、setter方法。查了下文档发现,OC的...
  • 【Spring基础】JDK动态代理实现原理(jdk8)

    万次阅读 多人点赞 2018-06-05 21:32:47
    前言 Github:... 一 JDK动态代理 在了解JDK动态代理前,有需要可以了解下代理模式。 ...天天的都听到人们说JDK动态代理,听上去感觉好屌的样子,为什么要叫JDK动态代理? ...
  • spring mvc启动时通过编程的方式添加filter和listener。借此可以通过启动参数决定过滤器和监听器的使用。
  • 创建动态代理对象bean,并动态注入到spring容器中

    万次阅读 多人点赞 2019-04-30 00:48:19
    这里mybatis就用到了JDK动态代理,并且将生成的接口代理对象动态注入到Spring容器中。 这里涉及到几个问题。也许有同学会有疑问,我们直接编写好类,加入@Component等注解不是可以注入了吗?或者在配置类(@...
  • 在Spring中的AOP是依靠动态代理来实现切面编程的. 而这两者又是有区别的. JDK是基于反射机制,生成匿名类,然后重写方法,实现方法的增强. 它生成类的速度很快,但是运行时因为是基于反射,调用后续的类操作会很慢. 而且...
  • .Net动态代理Castle系列

    千次阅读 2015-11-12 19:19:20
    自己接触NHibernate,Spring.Net,Moq这些框架有一段时间了,觉得很多很Cool的功能在这些框架中的实现都建立在动态代理这个技术之上,特来跟大家分享一下,希望大家一起讨论,一起进步,我的计划是这个系列将会有四篇...
  • Jdk动态代理 底层源码

    千次阅读 热门讨论 2020-03-16 23:36:56
    java动态代理主要有2种,Jdk动态代理、Cglib动态代理,本文主要讲解Jdk动态代理的使用、运行机制、以及源码分析。当spring没有手动开启Cglib动态代理,即:<aop:aspectj-autoproxy proxy-target-class="true"/>...
  • Java之代理... 1 一. 概念... 1 二. jdk的静态代理... 1 三. jdk动态代理... 4 四. cglib 动态代理... 7 五. jdk动态和cglib动态代理比较... 9
  • IOC容器的bean对象创建 ...,其中核心方法为AbstractAutowireCapableBeanFactory的createBean:首先检查是否创建了代理bean对象,如果创建了bean对象则直接返回;否则进入正常bean对象的创建流程,具...
  • 谈谈 Java 反射机制,动态代理是基于什么原理?典型回答反射机制是 Java 语言提供的一种基础功能,赋予程序在运行时自省(introspect,官方用语)的能力。通过反射我们可以直接操作类或者对象,比如获取某个对象的类...
  • QtTreePropertyBrowse添加大量properties比较慢,请教各位大神。谢谢。
  • java动态代理实现步骤解析

    千次阅读 2017-01-04 20:39:04
    代理模式的基本目的: 代理模式包含如下角色: ISubject:抽象主题角色,是一个接口。该接口是对象和它的代理共用的接口。 RealSubject:真实主题角色,是实现抽象主题接口的类。 Proxy:代理角色,内部含有对真实...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 245,193
精华内容 98,077
关键字:

动态代理添加属性