Java高薪技术学习总结-04

最新推荐文章于 2017-04-10 13:54:54 发布
最新推荐文章于 2017-04-10 13:54:54 发布
阅读量380 收藏
点赞数
分类专栏： Java入门 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/faith_yee/article/details/44773983
版权

Java高薪技术学习总结

Java高薪技术学习总结详解-04

4.9、分析代理类的作用与原理及AOP概念

  • 代理的概念与作用



  • AOP



  • 动态代理技术



5.0、创建动态类及查看其方法列表信息

分析JVM动态生成的类


Demo

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class ProxyTest {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
        System.out.println(clazzProxy1.getName());

        System.out.println("----------begin constructors list----------");
        /*$Proxy0()
        $Proxy0(InvocationHandler,int)*/
        Constructor[] constructors = clazzProxy1.getConstructors();
        for(Constructor constructor : constructors){
            String name = constructor.getName();
            StringBuilder sBuilder = new StringBuilder(name);
            sBuilder.append('(');
            Class[] clazzParams = constructor.getParameterTypes();
            for(Class clazzParam : clazzParams){
                sBuilder.append(clazzParam.getName()).append(',');
            }
            if(clazzParams!=null && clazzParams.length != 0)
                sBuilder.deleteCharAt(sBuilder.length()-1);
            sBuilder.append(')');
            System.out.println(sBuilder.toString());            
        }

        System.out.println("----------begin methods list----------");
        /*$Proxy0()
        $Proxy0(InvocationHandler,int)*/
        Method[] methods = clazzProxy1.getMethods();
        for(Method method : methods){
            String name = method.getName();
            StringBuilder sBuilder = new StringBuilder(name);
            sBuilder.append('(');
            Class[] clazzParams = method.getParameterTypes();
            for(Class clazzParam : clazzParams){
                sBuilder.append(clazzParam.getName()).append(',');
            }
            if(clazzParams!=null && clazzParams.length != 0)
                sBuilder.deleteCharAt(sBuilder.length()-1);
            sBuilder.append(')');
            System.out.println(sBuilder.toString());            
        }
    }
}

5.1、创建动态类的实例对象及调用其方法

Demo

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class ProxyTest {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
        System.out.println(clazzProxy1.getName());

        System.out.println("----------begin constructors list----------");
        /*$Proxy0()
        $Proxy0(InvocationHandler,int)*/
        Constructor[] constructors = clazzProxy1.getConstructors();
        for(Constructor constructor : constructors){
            String name = constructor.getName();
            StringBuilder sBuilder = new StringBuilder(name);
            sBuilder.append('(');
            Class[] clazzParams = constructor.getParameterTypes();
            for(Class clazzParam : clazzParams){
                sBuilder.append(clazzParam.getName()).append(',');
            }
            if(clazzParams!=null && clazzParams.length != 0)
                sBuilder.deleteCharAt(sBuilder.length()-1);
            sBuilder.append(')');
            System.out.println(sBuilder.toString());            
        }

        System.out.println("----------begin methods list----------");
        /*$Proxy0()
        $Proxy0(InvocationHandler,int)*/
        Method[] methods = clazzProxy1.getMethods();
        for(Method method : methods){
            String name = method.getName();
            StringBuilder sBuilder = new StringBuilder(name);
            sBuilder.append('(');
            Class[] clazzParams = method.getParameterTypes();
            for(Class clazzParam : clazzParams){
                sBuilder.append(clazzParam.getName()).append(',');
            }
            if(clazzParams!=null && clazzParams.length != 0)
                sBuilder.deleteCharAt(sBuilder.length()-1);
            sBuilder.append(')');
            System.out.println(sBuilder.toString());            
        }

        System.out.println("----------begin create instance object----------");
        //Object obj = clazzProxy1.newInstance();
        Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
        class MyInvocationHander1 implements InvocationHandler{

            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                // TODO Auto-generated method stub
                return null;
            }

        }
        Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHander1());

        System.out.println(proxy1);
        proxy1.clear();
        //proxy1.size();
        //System.out.println("111111111111111");
    }
}

5.2、完成InvocationHandler对象的内部功能

Demo

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class ProxyTest {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
        System.out.println(clazzProxy1.getName());

        System.out.println("----------begin constructors list----------");
        /*$Proxy0()
        $Proxy0(InvocationHandler,int)*/
        Constructor[] constructors = clazzProxy1.getConstructors();
        for(Constructor constructor : constructors){
            String name = constructor.getName();
            StringBuilder sBuilder = new StringBuilder(name);
            sBuilder.append('(');
            Class[] clazzParams = constructor.getParameterTypes();
            for(Class clazzParam : clazzParams){
                sBuilder.append(clazzParam.getName()).append(',');
            }
            if(clazzParams!=null && clazzParams.length != 0)
                sBuilder.deleteCharAt(sBuilder.length()-1);
            sBuilder.append(')');
            System.out.println(sBuilder.toString());            
        }

        System.out.println("----------begin methods list----------");
        /*$Proxy0()
        $Proxy0(InvocationHandler,int)*/
        Method[] methods = clazzProxy1.getMethods();
        for(Method method : methods){
            String name = method.getName();
            StringBuilder sBuilder = new StringBuilder(name);
            sBuilder.append('(');
            Class[] clazzParams = method.getParameterTypes();
            for(Class clazzParam : clazzParams){
                sBuilder.append(clazzParam.getName()).append(',');
            }
            if(clazzParams!=null && clazzParams.length != 0)
                sBuilder.deleteCharAt(sBuilder.length()-1);
            sBuilder.append(')');
            System.out.println(sBuilder.toString());            
        }

        System.out.println("----------begin create instance object----------");
        //Object obj = clazzProxy1.newInstance();
        Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
        class MyInvocationHander1 implements InvocationHandler{

            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                // TODO Auto-generated method stub
                return null;
            }

        }
        Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHander1());

        System.out.println(proxy1);
        proxy1.clear();
        //proxy1.size();
        //System.out.println("111111111111111");

        Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){

            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                return null;
            }

        });

        Collection proxy3 = (Collection)Proxy.newProxyInstance(
        Collection.class.getClassLoader(),
        new Class[]{Collection.class},
        new InvocationHandler(){
            ArrayList target = new ArrayList();
            public Object invoke(Object proxy,Method method,Object[]args)throws Throwable{
            //ArrayList target = new ArrayList();
            long beginTime = System.currentTimeMillis();
            Object retVal = method.invoke(target,args);
            long endTime = System.currentTimeMillis();
            System.out.println(method.getName()+"running time of"+(endTime - beginTime));
            return retVal;
            }
        });
        proxy3.add("zzz");
        proxy3.add("xxx");
        proxy3.add("yyy");
        System.out.println(proxy3.size());


    }
}

输出结果：


5.3、分析InvocationHandler对象的运行原理

猜想分析动态生成的类的内部代码



5.4、总结分析动态代理类的设计原理与结构

让动态生成类称为目标类的代理


画圈的log()表示一个对象中的log()方法。


以下就为之前代理类对象生成方式3改进。

5.5、编写可生成代理和插入通告的通用方法

Demo

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class ProxyTest {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        //模块化后的代理类的使用案例
        final ArrayList target = new ArrayList();            
        Collection proxy3 = (Collection)getProxy(target,new MyAdvice());
        proxy3.add("zxx");
        proxy3.add("lhm");
        proxy3.add("bxd");
        System.out.println(proxy3.size());
        System.out.println(proxy3.getClass().getName());
    }
    //被封装好的接收代理类的方法，并把实现好的接口传入到方法里，这样方法里就可以调用接口实现好的方法
    private static Object getProxy(final Object target,final Advice advice) {
        Object proxy3 = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                /*new Class[]{Collection.class},*/
                target.getClass().getInterfaces(),
                new InvocationHandler(){

                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                         //用来对比的原来没模块化的代码
                        /*long beginTime = System.currentTimeMillis();
                        Object retVal = method.invoke(target, args);
                        long endTime = System.currentTimeMillis();
                        System.out.println(method.getName() + " running time of " + (endTime - beginTime));
                        return retVal;*/


                        advice.beforeMethod(method);
                        Object retVal = method.invoke(target, args);
                        advice.afterMethod(method);
                        return retVal;                        

                    }
                }
                );
        return proxy3;
    }

}

实现接口并用来传入到封装好的接收代理类的方法里

Demo

import java.lang.reflect.Method;

public class MyAdvice implements Advice {
    long beginTime = 0;
    public void afterMethod(Method method) {
        // TODO Auto-generated method stub
        System.out.println("从传智播客毕业上班啦！");        
        long endTime = System.currentTimeMillis();
        System.out.println(method.getName() + " running time of " + (endTime - beginTime));

    }

    public void beforeMethod(Method method) {
        // TODO Auto-generated method stub
        System.out.println("到传智播客来学习啦！");
        beginTime = System.currentTimeMillis();
    }

}

接口：

Demo

import java.lang.reflect.Method;

public interface Advice {
    void beforeMethod(Method method);
    void afterMethod(Method method);
}

5.6、实现类似spring的可配置的AOP框架

实现AOP功能的封装与配置


类工厂BeanFactory：

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class BeanFactory {
    Properties props = new Properties();
    public BeanFactory(InputStream ips){
        try {
            props.load(ips);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public Object getBean(String name){
        String className = props.getProperty(name);
        Object bean = null;
        try {
            Class clazz = Class.forName(className);
            bean = clazz.newInstance();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
        if(bean instanceof ProxyFactoryBean){
            Object proxy = null;
            ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
            try {
                Advice advice = (Advice)Class.forName(props.getProperty(name + ".advice")).newInstance();
                Object target = Class.forName(props.getProperty(name + ".target")).newInstance();
                proxyFactoryBean.setAdvice(advice);
                proxyFactoryBean.setTarget(target);
                proxy = proxyFactoryBean.getProxy();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return proxy;
        }
        return bean;
    }
}

ProxyFactoryBean类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFactoryBean {

    private Advice advice;
    private Object target;

    public Advice getAdvice() {
        return advice;
    }

    public void setAdvice(Advice advice) {
        this.advice = advice;
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        // TODO Auto-generated method stub
        Object proxy3 = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                /*new Class[]{Collection.class},*/
                target.getClass().getInterfaces(),
                new InvocationHandler(){

                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {

                        /*long beginTime = System.currentTimeMillis();
                        Object retVal = method.invoke(target, args);
                        long endTime = System.currentTimeMillis();
                        System.out.println(method.getName() + " running time of " + (endTime - beginTime));
                        return retVal;*/


                        advice.beforeMethod(method);
                        Object retVal = method.invoke(target, args);
                        advice.afterMethod(method);
                        return retVal;                        

                    }
                }
                );
        return proxy3;
    }

}

接口Advice

import java.lang.reflect.Method;

public interface Advice {
    void beforeMethod(Method method);
    void afterMethod(Method method);
}

MyAdvice类

import java.lang.reflect.Method;

public class MyAdvice implements Advice {
    long beginTime = 0;
    public void afterMethod(Method method) {
        // TODO Auto-generated method stub
        System.out.println("从传智播客毕业上班啦！");        
        long endTime = System.currentTimeMillis();
        System.out.println(method.getName() + " running time of " + (endTime - beginTime));

    }

    public void beforeMethod(Method method) {
        // TODO Auto-generated method stub
        System.out.println("到传智播客来学习啦！");
        beginTime = System.currentTimeMillis();
    }

}

测试类：

import java.io.InputStream;
import java.util.Collection;

public class AopFrameworkTest {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
        Object bean = new BeanFactory(ips).getBean("xxx");
        System.out.println(bean.getClass().getName());
        ((Collection)bean).clear();
    }

}

config.properties配置文件

#xxx=java.util.ArrayList
xxx=cn.itcast.day3.aopframework.ProxyFactoryBean
xxx.advice=cn.itcast.day3.MyAdvice
xxx.target=java.util.ArrayList
faith_yee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
张孝祥Java高新技术myeclipse
03-07
总结起来，"张孝祥Java高新技术myeclipse"课程的核心内容是Java反射技术，特别是如何利用反射动态调用构造方法以及操作成员变量。掌握这些技术有助于提升Java编程的灵活性和解决复杂问题的能力。通过学习这个主题，...
年度工作总结及2021年工作计划-(JAVA开发工程师2).docx
12-18
在2020年，这位工程师承担了多项关键工程的研发与维护工作，包括政策兑现工程、政企直通车工程、高新技术企业认定管理平台、纪委监委干部管理系统以及快普管理系统的维护。这些项目覆盖了不同区域和行业，显示出他在...
StringBuilder删除最后一个字符
ithouse的专栏
04-10 9087
// 删除最后一个逗号 builder.deleteCharAt(builder.length()-1);
java 高新技术 总结(一)
浩宇碧海
01-05 907
java 技术提升，复习，总结（一） 1：方法的多变参数  看代码理解： public static void main(String[] args) { System.out.println(sum(1,2,3)); System.out.println(sumfor(1,2,3)); } /** * 多变参数 * @param i * @param args
Java生涯——高新技术---反射
hydznsqk的博客
03-14 211
第一讲    反射的应用场景 一、概述 反射技术：         Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类中的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。         简单一句话：反射技术可以对类进行解剖。   二、应用场景   
java 高新技术学习总结
qiufenglengwu的专栏
05-06 255
     今天的学习，从张老师的java高新技术视频开始，我明白了eclipse本身就是java开发出来的，启动它本身就是运行了java程序，以及高版本的java支持低版本，做到向后兼容，开发工具只是为了节省开发时间，以及使开发的项目工程化，由于当一个项目中包涵多个java源文件，这样工程化就显得重要了。   1：一个workspac可以包含多个project,一个workspace保留了eclipse的一套环境选项的配置。在eclipse上可以任意切换prespective非常方便。   2：在建立工程时
黑马程序员 Java高新技术---泛型
董方宇_java学习专栏
07-05 390
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 体验泛型 Jdk 1.5以前的集合类中存在什么问题  ArrayList collection = new ArrayList();  collection.add(1);  collection.add(1L)
黑马程序员——Java高新技术---反射
中仔的博客
11-27 526
------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------- 一、概述          一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。 反射技术：         Java反射机制
黑马程序员-----Java高新技术-----Java反射机制深入详解
qq_28176751的博客
05-21 393
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 这两天都在学习张孝祥老师的高新技术-反射，老师讲解的通俗易通，让我非常明白。今天，我就重温老师所说的知识，写一篇复习日志，把我在视频中学习到的都记录下来，方便自己以后学习和温习。 一、反射的概念 （1）反射就是把Java的各种成分映射成相应的Java类。 Clas
java高新技术开发实战重点总结
BUG的人生
03-24 594
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------ java高新技术开发实战 静态导入 静态导入——>import static语句导入一个类中的某个静态方法或所有静态方法,这将使代码更简洁, 提高编码效率。 import语句可以导入一个类或某个包中的所有类 import static语句导入一个类中
黑马程序员——高新技术---Java基础-集合特点和数据结构总结
oRuGuoYangGuangYu的博客
07-28 479
Collection接口： |---List 有序，可以存储重复元素 |----ArrayList 数组实现，线程不安全，效率高   |----Vector  数组实现，线程安全，效率低   |----LinkedList 链表实现，线程不安全，效率高   |---Set 无序，不能存储重复元素 |---HashSet哈希表实现，线程不安全，效率高 保证唯一性：has
黑马程序员——高新技术---反射
Andriod爱好者
07-02 407
第一讲    反射的应用场景 一、概述 反射技术：         Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类中的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。         简单一句话：反射技术可以对类进行解剖。   二、应用场景   
java3D代码及课设包
最新发布
01-03
这个"java3D代码及课设包"是海南大学针对Java3D技术的一个实验项目，包含了相关的源代码、复习资料和指导文档，旨在帮助学生理解和掌握Java3D的基本概念、原理以及实际应用。 首先，让我们来看看Java3D的核心知识点...
JavaNETndroidC语言学习视频.doc
09-30
张孝祥老师的Java高新技术视频教程针对已经掌握Java基础的人群，重点讲解高级主题，如多线程、并发库、高级API应用等。这些内容对于提升Java程序员的技能水平至关重要，因为它们涉及到实际项目中常见的复杂问题解决...
交通灯管理系统
faith_yee的专栏
03-30 1405
交通灯管理系统 交通灯管理系统详讲 模拟实现十字路口的交通灯管理系统逻辑，具体需求如下： *异步随机生成按照各个路线行驶的车辆。 例如： 由南向而来去往北向的车辆 ---- 直行车辆 由西向而来去往南向的车辆 ---- 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 ...... *信号灯忽略黄灯，只考虑红灯和绿灯。 *应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。
银行业务调度系统
faith_yee的专栏
03-30 559
银行业务调度系统 银行业务调度系统详解 模拟实现银行业务调度系统逻辑，具体需求如下： *银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。 *有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。 *异步随机生成各种类型的客户，生成各类型用户的概率比例为： *VIP客户 ：普通客户 ：快速客户 = 1
Java基础-03-java流程控制、函数及内存结构
faith_yee的专栏
03-30 552
Java基础 编程基础 1、程序流程控制 （1）、三元运算符 (x>y)?z:m; Eg: y = (x>1)?100:200; //若x>1则把100赋给y,否则把200赋给y三元运算符的特点：可以简化代码，但必须有一个结果。 （2）、选择结构 注意：if和switch都很像，但具体什么场景下，应用哪种语句呢？ 如果判断
Java基础-24-网络编程2
faith_yee的专栏
03-30 530
Java基础-网络编程 网络编程2 1、网络编程（TCP-上传图片） 需求：上传图片 客户端： （1）、服务端点 （2）、读取客户端已有的图片数据。 （3）、通过socket输出流将数据发给服务端 （4）、读取服务端反馈信息。 （5）、关闭资源。 测试代码： import java.io.*; import java.net.*; class PicClient {
Java入门精华：黑马程序员必知J2SE、高新技术与7K面试题
本篇文章是针对黑马程序员入学Java学习的精华总结，主要包括以下几个关键部分： 1. **J2SE基础与核心概念**： - 程序编程基础：介绍编程的基本概念。 - Java语言概览：讲述Java的历史、特点以及其跨平台性的原理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值