精华内容
下载资源
问答
  • 动态代理添加属性
    千次阅读 热门讨论
    2020-04-10 11:01:19

    java动态给实体类添加属性


    需要的jar包有两个: cglib-3.1.jargoogle-collections-1.0.jar
    如果是maven项目,就不需要cglib-3.1.jar,直接用spring自带的 org.springframework.cglib即可。
    1、创建一个实体:DynamicBean

    public class DynamicBean {
    
        private Object target;
        private BeanMap beanMap;
    
        public DynamicBean(Class superclass, Map<String, Class> propertyMap) {
            this.target = generateBean(superclass, propertyMap);
            this.beanMap = BeanMap.create(this.target);
        }
    
        public void setValue(String property, Object value) {
            beanMap.put(property, value);
        }
    
        public Object getValue(String property) {
            return beanMap.get(property);
        }
    
        public Object getTarget() {
            return this.target;
        }
        /**
         * 根据属性生成对象
         *
         */
        private Object generateBean(Class superclass, Map<String, Class> propertyMap) {
            BeanGenerator generator = new BeanGenerator();
            if (null != superclass) {
                generator.setSuperclass(superclass);
            }
            BeanGenerator.addProperties(generator, propertyMap);
            return generator.create();
        }
    }
    
    

    2、创建映射类,用来生成动态bean

    public class ReflectUtil {
    	private static Logger logger = LoggerFactory.getLogger(ReflectUtil.class);
    	
    	public static Object getObject(Object dest, Map<String, Object> addProperties) {
    	    PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
    	    PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(dest);
    	    Map<String, Class> propertyMap = Maps.newHashMap();
    	    for (PropertyDescriptor d : descriptors) {
    	        if (!"class".equalsIgnoreCase(d.getName())) {
    	            propertyMap.put(d.getName(), d.getPropertyType());
    	        }
    	    }
    	    addProperties.forEach((k, v) -> {
    	    	String sclass = v.getClass().toString();
    	    	if(sclass.equals("class java.util.Date")) {//对日期进行处理
    	    		propertyMap.put(k, Long.class);
    	    	}else {
    	    		propertyMap.put(k, v.getClass());
    	    	}
    	    	
    	    });
    	    DynamicBean dynamicBean = new DynamicBean(dest.getClass(), propertyMap);
    	    propertyMap.forEach((k, v) -> {
    	        try {
    	            if (!addProperties.containsKey(k)) {
    	                dynamicBean.setValue(k, propertyUtilsBean.getNestedProperty(dest, k));
    	            }
    	        } catch (Exception e) {
    	            logger.error("动态添加字段出错", e);
    	        }
    	    });
    	    addProperties.forEach((k, v) -> {
    	        try {
    	        	String sclass = v.getClass().toString();
    		    	if(sclass.equals("class java.util.Date")) {//动态添加的字段为date类型需要进行处理
    		    		Date date = (Date) v;
    		    		dynamicBean.setValue(k, date.getTime());
    		    	}else {
    		    		dynamicBean.setValue(k, v);
    		    	}
    	        } catch (Exception e) {
    	        	logger.error("动态添加字段值出错", e);
    	        }
    	    });
    	    Object obj = dynamicBean.getTarget();
    	    return obj;
    	}
    }
    
    

    3、使用方法
    现有一个用户实体User:

    public class User {
    
    	private String name;
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    }
    

    User只有一个name属性,现在要动态的为User添加年龄属性,代码如下:

    public static void main(String[] args) {
    		User user = new User();
    		user.setName("Daisy");
    		System.out.println("User:"+JSON.toJSONString(user));
    		Map<String,Object> propertiesMap = new HashMap<String,Object>();
    		propertiesMap.put("age", 18);
    		Object obj = ReflectUtil.getTarget(user, propertiesMap);
    		System.out.println("动态为User添加age之后,User:"+JSON.toJSONString(obj));
    }
    

    打印结果如下:

    User:{"name":"Daisy"}
    动态为User添加age之后,User:{"age":18,"name":"Daisy"}
    
    更多相关内容
  • Java 动态为类添加属性

    千次阅读 2019-10-11 09:28:37
    “衰兰送客咸阳道,天若有情天亦老” 序 有一个这样的功能:展示一个报表,表头是动态的,可以手动新增或删除,也就是说会修改表结构,...但是这里说说给实体类动态添加属性。 实现代码 import com.google.common...

    “衰兰送客咸阳道,天若有情天亦老”

    有一个这样的功能:展示一个报表,表头是动态的,可以手动新增或删除,也就是说会修改表结构,新增或删除表字段。然而一般实体类都是对应表结构的,那么如何给实体增加属性呢?虽然我自己的解决方案是直接返回List<map>,然后让对应的列适配到map的key中。但是这里说说给实体类动态添加属性。

    实现代码

    
    import com.google.common.collect.Maps;
    import net.sf.cglib.beans.BeanGenerator;
    import net.sf.cglib.beans.BeanMap;
    import org.apache.commons.beanutils.PropertyUtilsBean;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     *@author 
     *@date 2019/10/9
     *@description
     */
    public class ReflectUtil {
    
        static Logger logger = LoggerFactory.getLogger(ReflectUtil.class);
    
        public static Object getTarget(Object dest, Map<String, Object> addProperties) {
            // get property map
            PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
            PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(dest);
            Map<String, Class> propertyMap = Maps.newHashMap();
            for (PropertyDescriptor d : descriptors) {
                if (!"class".equalsIgnoreCase(d.getName())) {
                    propertyMap.put(d.getName(), d.getPropertyType());
                }
            }
            // add extra properties
            for (Map.Entry<String, Object> entry : addProperties.entrySet()) {
                propertyMap.put(entry.getKey(), entry.getValue().getClass());
            }
    //        addProperties.forEach((k, v) -> propertyMap.put(k, v.getClass()));
            // new dynamic bean
            DynamicBean dynamicBean = new DynamicBean(dest.getClass(), propertyMap);
            // add old value
            for (Map.Entry<String, Class> entry : propertyMap.entrySet()) {
                try {
                    // filter extra properties
                    if (!addProperties.containsKey(entry.getKey())) {
                        dynamicBean.setValue(entry.getKey(), propertyUtilsBean.getNestedProperty(dest, entry.getKey()));
                    }
                } catch (Exception e) {
                    logger.error(e.getMessage(), e);
                }
            }
            ;
            // add extra value
            for (Map.Entry<String, Object> entry : addProperties.entrySet()) {
                try {
                    dynamicBean.setValue(entry.getKey(), entry.getValue());
                } catch (Exception e) {
                    logger.error(e.getMessage(), e);
                }
            }
            ;
            Object target = dynamicBean.getTarget();
            return target;
        }
    
        public static class DynamicBean {
            /**
             * 目标对象
             */
            private Object target;
    
            /**
             * 属性集合
             */
            private BeanMap beanMap;
    
            public DynamicBean(Class superclass, Map<String, Class> propertyMap) {
                this.target = generateBean(superclass, propertyMap);
                this.beanMap = BeanMap.create(this.target);
            }
    
    
            /**
             * bean 添加属性和值
             *
             * @param property
             * @param value
             */
            public void setValue(String property, Object value) {
                beanMap.put(property, value);
            }
    
            /**
             * 获取属性值
             *
             * @param property
             * @return
             */
            public Object getValue(String property) {
                return beanMap.get(property);
            }
    
            /**
             * 获取对象
             *
             * @return
             */
            public Object getTarget() {
                return this.target;
            }
    
    
            /**
             * 根据属性生成对象
             *
             * @param superclass
             * @param propertyMap
             * @return
             */
            private Object generateBean(Class superclass, Map<String, Class> propertyMap) {
                BeanGenerator generator = new BeanGenerator();
                if (null != superclass) {
                    generator.setSuperclass(superclass);
                }
                BeanGenerator.addProperties(generator, propertyMap);
                return generator.create();
            }
        }
    
        public static void main(String[] args) {
            TestClass entity = new TestClass();
            entity.setAge(15);
            entity.setId(1);
            entity.setName("张三");
            //动态设置属性字段
            Map<String, Object> addProperties = new HashMap() {{
                put("sex", "男");
                put("telephone", "123456789");
            }};
            //获取实体中给属性的值
            Object target = getTarget(entity, addProperties);
            System.out.println(getFieldValueByName("id", target));
            System.out.println(getFieldValueByName("name", target));
            System.out.println(getFieldValueByName("age", target));
            System.out.println(getFieldValueByName("sex", target));
            System.out.println(getFieldValueByName("telephone", target));
        }
    
        //获取实体中属性的值
        private static Object getFieldValueByName(String fieldName, Object o) {
            try {
                //通过反射获取值
                String firstLetter = fieldName.substring(0, 1).toUpperCase();
                String getter = "get" + firstLetter + fieldName.substring(1);
                Method method = o.getClass().getMethod(getter, new Class[]{});
                Object value = method.invoke(o, new Object[]{});
                return value;
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
                return null;
            }
        }
    
        //测试类
        public static class TestClass{
            //ID
            private int id;
            //名字
            private String name;
            //年龄
            private int age;
    
            public int getId() {
                return id;
            }
    
            public void setId(int id) {
                this.id = id;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public int getAge() {
                return age;
            }
    
            public void setAge(int age) {
                this.age = age;
            }
        }
    
    }
    
    

    结果:
    在这里插入图片描述
    本文参考至:JAVA“动态”为类添加属性

    展开全文
  • JAVA“动态”为类添加属性

    千次阅读 2021-02-12 19:38:58
    部分参考:http://www.cnblogs.com/zy2009/p/6725843.htmlpom.xml中添加:commons-beanutilscommons-beanutils1.9.3cglibcglib-nodep3.2.4使用cglib动态生成类与使用 commons-beanutils获取源对象属性-类型集合,...

    部分参考:http://www.cnblogs.com/zy2009/p/6725843.html

    pom.xml中添加:

    commons-beanutils

    commons-beanutils

    1.9.3

    cglib

    cglib-nodep

    3.2.4

    使用cglib动态生成类与使用 commons-beanutils获取源对象属性-类型集合,封装成新对象并设置值代码:

    package com.frinder.util;

    import com.google.common.collect.Maps;

    import com.kiktech.entity.LoggerEntity;

    import net.sf.cglib.beans.BeanGenerator;

    import net.sf.cglib.beans.BeanMap;

    import org.apache.commons.beanutils.PropertyUtilsBean;

    import org.slf4j.Logger;

    import org.slf4j.LoggerFactory;

    import java.beans.PropertyDescriptor;

    import java.util.HashMap;

    import java.util.Map;

    /**

    * Created by frinder on 2017/7/18.

    */

    public class ReflectUtil {

    static Logger logger = LoggerFactory.getLogger(ReflectUtil.class);

    public static Object getTarget(Object dest, Map addProperties) {

    // get property map

    PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();

    PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(dest);

    Map propertyMap = Maps.newHashMap();

    for (PropertyDescriptor d : descriptors) {

    if (!"class".equalsIgnoreCase(d.getName())) {

    propertyMap.put(d.getName(), d.getPropertyType());

    }

    }

    // add extra properties

    addProperties.forEach((k, v) -> propertyMap.put(k, v.getClass()));

    // new dynamic bean

    DynamicBean dynamicBean = new DynamicBean(dest.getClass(), propertyMap);

    // add old value

    propertyMap.forEach((k, v) -> {

    try {

    // filter extra properties

    if (!addProperties.containsKey(k)) {

    dynamicBean.setValue(k, propertyUtilsBean.getNestedProperty(dest, k));

    }

    } catch (Exception e) {

    logger.error(e.getMessage(), e);

    }

    });

    // add extra value

    addProperties.forEach((k, v) -> {

    try {

    dynamicBean.setValue(k, v);

    } catch (Exception e) {

    logger.error(e.getMessage(), e);

    }

    });

    Object target = dynamicBean.getTarget();

    return target;

    }

    public static void main(String[] args) {

    LoggerEntity entity = new LoggerEntity();

    entity.setAppName("appname");

    entity.setOperator("add");

    entity.setResult("result");

    entity.setUri("uri");

    entity.setMethod("method");

    Map addProperties = new HashMap() {{

    put("hello", "world");

    put("abc", "123");

    }};

    System.out.println(getTarget(entity, addProperties));

    }

    public static class DynamicBean {

    /**

    * 目标对象

    */

    private Object target;

    /**

    * 属性集合

    */

    private BeanMap beanMap;

    public DynamicBean(Class superclass, Map propertyMap) {

    this.target = generateBean(superclass, propertyMap);

    this.beanMap = BeanMap.create(this.target);

    }

    /**

    * bean 添加属性和值

    *

    * @param property

    * @param value

    */

    public void setValue(String property, Object value) {

    beanMap.put(property, value);

    }

    /**

    * 获取属性值

    *

    * @param property

    * @return

    */

    public Object getValue(String property) {

    return beanMap.get(property);

    }

    /**

    * 获取对象

    *

    * @return

    */

    public Object getTarget() {

    return this.target;

    }

    /**

    * 根据属性生成对象

    *

    * @param superclass

    * @param propertyMap

    * @return

    */

    private Object generateBean(Class superclass, Map propertyMap) {

    BeanGenerator generator = new BeanGenerator();

    if (null != superclass) {

    generator.setSuperclass(superclass);

    }

    BeanGenerator.addProperties(generator, propertyMap);

    return generator.create();

    }

    }

    }

    LoggerEntity代码:

    package com.frinder.entity;

    import net.logstash.logback.encoder.org.apache.commons.lang.builder.ReflectionToStringBuilder;

    /**

    * Created by frinder on 2017/5/24.

    */

    public class LoggerEntity {

    private String method;

    private String uri;

    private Object[] args;

    private Object result;

    private String operator;

    private String appName;

    /**

    * 获取当前对象

    *

    * @param method

    * @param uri

    * @param args

    * @param result

    * @return

    */

    public LoggerEntity get(String method, String uri, Object[] args, Object result, String operator, String appName) {

    setMethod(method);

    setUri(uri);

    setArgs(args);

    setResult(result);

    setOperator(operator);

    setAppName(appName);

    return this;

    }

    public String getMethod() {

    return method;

    }

    public void setMethod(String method) {

    this.method = method;

    }

    public String getUri() {

    return uri;

    }

    public void setUri(String uri) {

    this.uri = uri;

    }

    public Object[] getArgs() {

    return args;

    }

    public void setArgs(Object[] args) {

    this.args = args;

    }

    public Object getResult() {

    return result;

    }

    public void setResult(Object result) {

    this.result = result;

    }

    public String getOperator() {

    return operator;

    }

    public void setOperator(String operator) {

    this.operator = operator;

    }

    public String getAppName() {

    return appName;

    }

    public void setAppName(String appName) {

    this.appName = appName;

    }

    @Override

    public String toString() {

    return ReflectionToStringBuilder.toString(this);

    }

    }

    测试结果,需要在调试模式下才能看到:

    b34836d7ef41001553cc4e7a1a90a1b2.png

    展开全文
  • 这两者最大的区别在于基于 JDK 的动态代理需要被代理的对象有接口,而基于 Cglib 的动态代理并不需要被代理对象有接口。 那么小伙伴们不禁要问,Spring 中的 AOP 是怎么实现的?是基于 JDK 的动态

    周六发了一个抽奖送书的活动,不过抽奖的人不多,中奖率蛮高的,小伙伴们可以去试试运气:

    好啦,开始今天的正文。

    大家都知道,AOP 底层是动态代理,而 Java 中的动态代理有两种实现方式:

    • 基于 JDK 的动态代理
    • 基于 Cglib 的动态代理

    这两者最大的区别在于基于 JDK 的动态代理需要被代理的对象有接口,而基于 Cglib 的动态代理并不需要被代理对象有接口。

    那么小伙伴们不禁要问,Spring 中的 AOP 是怎么实现的?是基于 JDK 的动态代理还是基于 Cglib 的动态代理?

    1. Spring

    先来说结论,Spring 中的动态代理,具体用哪种,分情况:

    • 如果代理对象有接口,就用 JDK 动态代理,否则就是 Cglib 动态代理。
    • 如果代理对象没有接口,那么就直接是 Cglib 动态代理。

    来看看这段来自官方文档的说辞:

    可以看到,即使在最新版的 Spring 中,依然是如上策略不变。即能用 JDK 做动态代理就用 JDK,不能用 JDK 做动态代理就用 Cglib,即首选 JDK 做动态代理。

    2. Spring Boot

    Spring Boot 和 Spring 一脉相承,那么在动态代理这个问题上是否也是相同的策略呢?抱歉,这个还真不一样。

    Spring Boot 中对这个问题的处理,以 Spring Boot2.0 为节点,前后不一样。

    在 Spring Boot2.0 之前,关于 Aop 的自动化配置代码是这样的(Spring Boot 1.5.22.RELEASE):

    @Configuration
    @ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class })
    @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
    public class AopAutoConfiguration {
    
    	@Configuration
    	@EnableAspectJAutoProxy(proxyTargetClass = false)
    	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
    			matchIfMissing = true)
    	public static class JdkDynamicAutoProxyConfiguration {
    
    	}
    
    	@Configuration
    	@EnableAspectJAutoProxy(proxyTargetClass = true)
    	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
    			matchIfMissing = false)
    	public static class CglibAutoProxyConfiguration {
    
    	}
    
    }
    

    可以看到,这个自动化配置主要是在讨论 application.properties 配置文件中的 spring.aop.proxy-target-class 属性的值。

    具体起作用的是 @ConditionalOnProperty 注解,关于这个注解中的几个属性,松哥也来稍微说下:

    • prefix:配置文件的前缀。
    • name:配置文件的名字,和 prefix 共同组成配置的 key。
    • having:期待配置的值,如果实际的配置和 having 的值相同,则这个配置就会生效,否则不生效。
    • matchIfMissing:如果开发者没有在 application.properties 中进行配置,那么这个配置类是否生效。

    基于如上介绍,我们很容易看出:

    • 如果开发者设置了 spring.aop.proxy-target-class 为 false,则使用 JDK 代理。
    • 如果开发者设置了 spring.aop.proxy-target-class 为 true,则使用 Cglib 代理。
    • 如果开发者一开始就没配置 spring.aop.proxy-target-class 属性,则使用 JDK 代理。

    这是 Spring Boot 2.0 之前的情况。

    再来看看 Spring Boot 2.0(含)之后的情况(Spring Boot 2.0.0.RELEASE):

    @Configuration
    @ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class,
    		AnnotatedElement.class })
    @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
    public class AopAutoConfiguration {
    
    	@Configuration
    	@EnableAspectJAutoProxy(proxyTargetClass = false)
    	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false)
    	public static class JdkDynamicAutoProxyConfiguration {
    
    	}
    
    	@Configuration
    	@EnableAspectJAutoProxy(proxyTargetClass = true)
    	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true)
    	public static class CglibAutoProxyConfiguration {
    
    	}
    
    }
    

    可以看到,大部分配置都是一样的,有一个地方不太相同,那就是 matchIfMissing 属性的值。可以看到,从 Spring Boot2.0 开始,如果用户什么都没有配置,那么默认情况下使用的是 Cglib 代理。

    3. 实践

    最后我们写一个简单的例子验证一下我们的想法。

    首先创建一个 Spring Boot 项目(本案例使用最新版 Spring Boot,即默认使用 Cglib 代理),加入三个依赖即可,如下:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    

    接下来我们创建一个 IUserService 接口,如下:

    public interface IUserService {
        void hello();
    }
    

    然后我们再来创建一个该接口的实现类:

    @Service
    public class UserServiceImpl implements IUserService {
        @Override
        public void hello() {
    
        }
    }
    

    方法不用实现。

    再来一个简单的切面:

    @EnableAspectJAutoProxy
    @Aspect
    @Component
    public class LogAspect {
        @Before("execution(* org.javaboy.demo.UserServiceImpl.*(..))")
        public void before(JoinPoint jp) {
            System.out.println("jp.getSignature().getName() = " + jp.getSignature().getName());
        }
    }
    

    最后再来一个简单的测试方法,注入 IUserService 实例:

    @RestController
    public class HelloController {
        @Autowired
        IUserService iUserService;
        @GetMapping("/hello")
        public void hello() {
            iUserService.hello();
        }
    }
    

    DBUEG 运行一下,就可以看到 IUserService 是通过 Cglib 来代理的。

    如果我们想用 JDK 来代理,那么只需要在 application.properties 中添加如下配置即可:

    spring.aop.proxy-target-class=false
    

    添加完成后,重新 DEBUG,如下图:

    可以看到,已经使用了 JDK 动态代理了。

    如果用的是 Spring Boot 1.5.22.RELEASE 这个版本,那么即使不在 application.properties 中添加配置,默认也是 JDK 代理,这个我就不测试了,小伙伴们可以自己来试试。

    4. 小结

    总结一下:

    1. Spring 中的 AOP,有接口就用 JDK 动态代理,没有接口就用 Cglib 动态代理。
    2. Spring Boot 中的 AOP,2.0 之前和 Spring 一样;2.0 之后首选 Cglib 动态代理,如果用户想要使用 JDK 动态代理,需要自己手动配置。

    just this。

    展开全文
  • 代理模式(Proxy Pattern)是一种结构性模式。代理模式为一个对象提供了一个替身,以控制对这个对象的访问。即通过代理对象访问目标目标对象,可以在目标对象实现的基础上,增强额外的功能操作...动态代理 cglib代理 应用
  • Java动态代理在一些中间件中经常用到,或者一些大型项目中都会用到。 这里顺带使用一下自定义注解方式,基于java 反射机制读取.properties格式文件。 demo的大致内容包含以下: 1.配置文件:config.properties url=...
  • Java动态生成类以及动态添加属性

    万次阅读 2014-08-10 17:25:15
    有个技术实现需求:动态生成类,其中类中的属性来自参数对象中的全部属性以及来自参数对象propertities文件。  那么技术实现支持:使用cgilib代理。  具体的实现步骤:  1.cglib的jar包(cglib-nodep):我用...
  • 1、实现对Controller接口的动态代理 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface MyController { String value() default ""; } @Target(ElementType.METHOD) @Retention...
  • 动态代理织入,在运行期为目标类添加通知生成子类的方式。Spring AOP框架默认采用动态代理织入,而AspectJ(基于Java语言的AOP框架)采用编译器织入和类装载期织入。就是将原来的方法,与其它类的方法一起调用 3. ...
  • 动态代理,反射的用途及实现

    千次阅读 2018-11-29 14:51:45
    在Java中的反射机制是指在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法,这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制 ...
  • 实现原理类似于JDK的动态代理,只是它在运行期间生成目标类扩展的子类对象.(也就是通过继承的方式创建的代理类).CGLIB是高效的代码生成包,底层是依靠ASM(开源的Java字节码编辑类库)操字节码实现的,性能比JDK强. ...
  • 超全MyBatis动态代理详解!(绝对干货)

    千次阅读 多人点赞 2021-01-20 09:30:23
    Class 对象 添加到对应的映射器容器中,等待生成动态代理对象 如果此时调用生成动态代理对象,代理工厂 newInstance 方法如下: 至此,文初提的 Proxy、Mybatis 动态代理相关问题已全部答疑 抽象类能否 JDK 动态代理...
  • java中动态修改注解的某个属性

    千次阅读 2020-09-15 19:57:08
    这个题目我并不是很熟悉,不过根据题目描述和查阅相关Spring 创建定时任务的资料,发现这也许涉及到通过Java代码动态修改注解的属性值。 今天对此尝试了一番,发现通过反射来动态修改注解的属性值是可以做到的: ...
  • JDK和Cglib两种动态代理方式区别 1、java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。而Cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过...
  • 秒懂Java代理动态代理模式

    万次阅读 多人点赞 2018-06-30 17:08:23
    什么是动态代理模式?二者什么关系?具体如何实现?什么原理?如何改进?这即为我们学习一项新知识的正确打开方式,我们接下来会以此展开,让你秒懂。 概念 什么是代理模式 定义:为其他对象提供一种代理以控制...
  • 【Spring基础】JDK动态代理实现原理(jdk8)

    万次阅读 多人点赞 2018-06-05 21:32:47
    前言 Github:... 一 JDK动态代理 在了解JDK动态代理前,有需要可以了解下代理模式。 ...天天的都听到人们说JDK动态代理,听上去感觉好屌的样子,为什么要叫JDK动态代理? ...
  • 一、什么是代理代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理。详细介绍请参考:...
  • 反观扩展(extension),作用是为一个已知的类添加一些私有的信息,必须有这个类的源码,才能扩展,它是在编译器生效的,所以能直接为类添加属性或者实例变量。 ####由此推想protocol添加属性会怎么? 由上面的分析...
  • 一、代理设计模式 首先,要明确什么是代理。通俗的说,就是日常生活中的中介。比如你要租房子,找了中介,中介负责打理你的一切事务(找房、签约等),这些事务你都不用做,你就负责住房就可以。代理同理,如果你想...
  • 在介绍过滤器Filter和拦截器Interceptor之前,先大篇幅介绍下Java反射机制和动态代理(本来想着只是简单说明下这两个名称,但下笔介绍过程中发现对反射机制和动态代理一知半解,随进行了深入了解和源码剖析),动态...
  • IOC容器的bean对象创建 ...,其中核心方法为AbstractAutowireCapableBeanFactory的createBean:首先检查是否创建了代理bean对象,如果创建了bean对象则直接返回;否则进入正常bean对象的创建流程,具...
  • Spring之IOC与动态代理

    千次阅读 2018-12-27 10:27:43
     可见,动态代理比静态代理更加灵活,它的核心是 java.lang.reflect.Proxy代理类,该类位于reflect反射包下,可知动态代理当中是用了反射的技术来实现的。  接下来,我们再看基于类实现的动态代理。此处需要在...
  • java动态代理实现步骤解析

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

    千次阅读 2020-01-08 10:36:51
    反射、动态代理、Spring AOP 反射 反射是什么? 反射是程序在运行时可以动态的获取类的信息。包括: 类的属性 类的构造器 类的方法 反射可以在获取类的信息后调用其方法。 反射的应用场景 IDEA 可以知道类的方法...
  • 动态代理的几种实现方式及优缺点

    千次阅读 2020-02-13 17:32:05
    动态代理:是使用反射和字节码,在运行期间创建指定接口或类的子类以及它的实例对象的一项技术,通过这个技术可以对代码进行无侵入式的增强。 源文件生成实例对象的过程如下: 关于动态代理的底层原理,在另一篇...
  • 动态代理的原理及其应用

    千次阅读 2018-08-07 22:29:46
    动态代理的介绍 动态代理是一种在运行时动态地创建代理对象,动态地处理代理方法调用的机制。 实际上它是一种代理机制。代理可以看做是对调用目标的一个封装,直接通过代理来实现对目标代码的调用 与静态代理的...
  • 不重启JVM动态添加日志(阿里Arthas)

    千次阅读 多人点赞 2021-01-28 00:26:29
    如果生产环境临时出现故障,但是现运行代码未打印定位问题所需要的日志,我们通常的做法是添加日志->重新发布->重现故障。但是这样麻烦不说,最重要的是重启节点会丢失现场,也不一定能重现问题。所以我们希望找到一...
  • 在Spring中的AOP是依靠动态代理来实现切面编程的. 而这两者又是有区别的. JDK是基于反射机制,生成匿名类,然后重写方法,实现方法的增强. 它生成类的速度很快,但是运行时因为是基于反射,调用后续的类操作会很慢. 而且...
  • 很多时候我们需要监听动态添加的元素事件。 举个例子: 页面中有一个div,div中有一个button以及一个table,我们需要在点击button的时候相应的table行进行排序,而根据特定需求ajax返回数据中的table值是变化的, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 276,542
精华内容 110,616
关键字:

动态代理添加属性