day19_java基础加强_动态代理+注解+类加载器

一、动态代理

1.1、代理模式

? ? 什么是代理模式及其作用？

? ? ? ? Proxy Pattern（即：代理模式），23种常用的面向对象软件的设计模式之一。
? ? ? ? 代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。
? ? ? ? 在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
? ? 优点：
? ? ? ? (1) 职责清晰，真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。
? ? ? ? (2) 代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了保护目标对象的作用。
? ? ? ? (3) 高扩展性。
? ? 结构：
? ? ? ? 一个是你要访问的真正的对象(目标类)，另一个是代理对象，真正对象(目标对象)与代理对象实现同一个接口，先访问代理类再访问真正要访问的对象。
? ? ? ? 其实装饰设计模式就是静态代理。

? ? 静态代理模式简单案例：

? ? KindWomen.java（接口）

package com.itheima.demo;public interface KindWomen {    public void throwEye();    public void doSomething();}

? ? PJL.java（目标类1 实现 接口，并具体实现）

package com.itheima.demo;public class PJL implements KindWomen {    @Override    public void throwEye() {        System.out.println("潘金莲抛媚眼");    }    @Override    public void doSomething() {        System.out.println("潘金莲XOXO");    }}

? ? YPX.java（目标类2 实现 接口，并具体实现）

package com.itheima.demo;public class YPX implements KindWomen {    @Override    public void throwEye() {        System.out.println("阎婆惜抛媚眼");    }    @Override    public void doSomething() {        System.out.println("阎婆惜XOXO");    }}

? ? WP.java（代理类 也实现接口，但是空实现）

package com.itheima.demo;public class WP implements KindWomen {    private KindWomen kw;    public WP(KindWomen kw) {        this.kw = kw;    }    @Override    public void throwEye() {        kw.throwEye();    }    @Override    public void doSomething() {        kw.doSomething();    }}

? ? XMQ.java（我）

package com.itheima.demo;public class XMQ {    public static void main(String[] args) {        PJL pjl = new PJL();        YPX ypx = new YPX();        KindWomen wp1 = new WP(pjl);        KindWomen wp2 = new WP(ypx);        wp1.throwEye();        wp1.doSomething();        wp2.throwEye();        wp2.doSomething();}

1.2、动态代理

? ? 动态代理它可以直接给某一个目标对象生成一个代理对象，而不需要代理类存在。
? ? 动态代理与代理模式原理是一样的，只是它没有具体的代理类，直接通过反射生成了一个代理对象。
? ? 动态代理生成技术:
? ? ? ? 1. 基于jdk提供一个Proxy类，可以直接给实现某接口的实现类直接生成代理对象。
? ? ? ? 2. 基于cglib (spring框架会学习)

? ? java.lang.reflect.Proxy; ? 该类可以直接生成一个代理对象。

? ? Proxy类的方法：
? ? ? ? public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 返回一个指定接口的代理类实例。
? ? ? ? ? ? 仅能代理实现至少一个接口的类(即目标对象需要至少有一个接口)。
? ? ? ? ? ? ClassLoader：类加载器。固定写法，和被代理类使用相同的类加载器即可。
? ? ? ? ? ? Class[]：代理类要实现的接口。固定写法，和被代理类使用相同的接口即可。
? ? ? ? ? ? InvocationHandler：策略（方案）设计模式的应用。如何去具体实现代理，由我们自己决定。

? ? InvocationHandler接口中的invoke方法：调用代理类的任何方法，此方法都会执行。
? ? ? ? Object invoke(Object proxy, Method method, Object[] args)
? ? ? ? ? ? Object proxy：代理对象本身的引用。一般用不着。
? ? ? ? ? ? Method method：当前调用的方法。
? ? ? ? ? ? Object[] args：当前方法用到的参数。

? ? 动态代理模式简单案例：

? ? KindWomen.java（接口）

package com.itheima.demo;public interface KindWomen {    public void throwEye(double money);    public void doSomething(double money);}

? ? PJL.java（目标类1 实现 接口，并具体实现）

package com.itheima.demo;public class PJL implements KindWomen {    @Override    public void throwEye(double money) {        System.out.println("潘金莲拿了" + money + "元钱，抛媚眼");    }    @Override    public void doSomething(double money) {        System.out.println("潘金莲拿了" + money + "元钱，XOXO");    }}

? ? XMQ.java（我）

package com.itheima.demo;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class XMQ {    public static void main(String[] args) {        final KindWomen kw = new PJL(); // 真实对象（目标对象）        // final YPX ypx = new YPX();        // PJL pjl = new PJL();        // YPX ypx = new YPX();        // KindWomen wp1 = new WP(pjl);        // KindWomen wp2 = new WP(ypx);        // wp1.throwEye();        // wp1.doSomething();        // wp2.throwEye();        // wp2.doSomething();        // public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)         // 返回一个指定接口的代理类实例。仅能代理实现至少一个接口的类(即目标对象至少有一个接口)。        KindWomen proxy = (KindWomen) Proxy.newProxyInstance(kw.getClass().getClassLoader(), kw.getClass().getInterfaces(), new InvocationHandler() {            @Override            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                System.out.println("代理拿了酬金，去帮你做事情，事情如下：");                Object o = method.invoke(kw, new Object[] { (Double) args[0] / 2 }); // 这是真实对象执行的方法(做的事情)                System.out.println("代理去做别的事情了");                return o;            }        });        proxy.throwEye(5);        proxy.doSomething(10);    }}

? ? 静态/动态代理图解：

1.3、AOP(面向切面编程)编程思想（Spring框架中的核心思想之一）

? ? Spring框架中的核心思想包括：
? ? ? ? Dependency Injection(依赖注入)
? ? ? ? Inverse of Control(控制反转)
? ? ? ? Aspect Oriented Programming(面向切面编程)

? ? AOP编程思想解决的问题：
? ? ? ? 1、问题：业务的方法日后会很多，这样会有很多重复的代码。
? ? ? ? 2、问题：业务已经存在很多的方法，并没有考虑到事务的问题，现在要求加上。那么业务的重心就变了。

? ? 动态代理实现AOP示例代码：（转账功能）
? ? 完成业务的代码：

package com.itheima.service.impl;import com.itheima.dao.AccountDao;import com.itheima.dao.impl.AccountDaoImpl;import com.itheima.domain.Account;import com.itheima.service.AccountService;public class AccountServiceImpl implements AccountService {    @Override // 运用AOP思想，转账功能就是转账功能，不要加其他的东西，比如事务控制、日志、权限控制等，这样代码健壮性好，优美。    public void transfer(String fromname, String toname, double money) throws Exception {        // ad.updateAccount(fromname, toname, money);        AccountDao ad = new AccountDaoImpl();        // 分别得到转出和转入账户对象        Account fromAccount = ad.findAccountByName(fromname);        Account toAccount = ad.findAccountByName(toname);        // 修改账户各自的金额        fromAccount.setMoney(fromAccount.getMoney() - money);        toAccount.setMoney(toAccount.getMoney() + money);        // 完成转账操作        ad.updateAccout(fromAccount);        // int i = 10 / 0;        ad.updateAccout(toAccount);    }}/*package com.itheima.service.impl;import java.sql.Connection;import java.sql.SQLException;import com.itheima.dao.AccountDao;import com.itheima.dao.impl.AccountDaoImpl;import com.itheima.domain.Account;import com.itheima.service.AccountService;import com.itheima.util.C3P0Util;import com.itheima.util.ManagerThreadLocal;public class AccountServiceImpl implements AccountService {    @Override    public void transfer(String fromname, String toname, double money) {        // ad.updateAccount(fromname, toname, money);        AccountDao ad = new AccountDaoImpl();        try {            ManagerThreadLocal.startTransacation(); // 开启事务            // 分别得到转出和转入账户对象            Account fromAccount = ad.findAccountByName(fromname);            Account toAccount = ad.findAccountByName(toname);            // 修改账户各自的金额            fromAccount.setMoney(fromAccount.getMoney() - money);            toAccount.setMoney(toAccount.getMoney() + money);            // 完成转账操作            ad.updateAccout(fromAccount);            // int i = 10 / 0;            ad.updateAccout(toAccount);            ManagerThreadLocal.commit(); // 提交事务        } catch (Exception e) {            try {                ManagerThreadLocal.rollback(); // 回滚事务            } catch (Exception e1) {                e1.printStackTrace();            }        } finally {            try {                ManagerThreadLocal.close(); // 关闭            } catch (Exception e) {                e.printStackTrace();            }         }    }}*/

? ? 产生代理对象的工厂代码：

package com.itheima.util;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import com.itheima.service.AccountService;import com.itheima.service.impl.AccountServiceImpl;public class ObjectFactory {    // 该方法返回一个代理对象    public static AccountService getAccountService() {        final AccountService as = new AccountServiceImpl(); // 真实对象（目标对象）        AccountService proxy = (AccountService) Proxy.newProxyInstance(as.getClass().getClassLoader(),                as.getClass().getInterfaces(), new InvocationHandler() {                    @Override                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                        Object invoke = null;                        try {                            ManagerThreadLocal.startTransacation(); // 开启事务                            // 执行的是真实对象的转账方法                            invoke = method.invoke(as, args);                            ManagerThreadLocal.commit(); // 提交事务                        } catch (Exception e) {                            try {                                ManagerThreadLocal.rollback(); // 回滚事务                            } catch (Exception e1) {                                e1.printStackTrace();                            }                        } finally {                            try {                                ManagerThreadLocal.close(); // 关闭                            } catch (Exception e) {                                e.printStackTrace();                            }                         }                        return invoke;                    }                });        return proxy;    }}

? ? 测试类代码：

package com.itheima.test;import com.itheima.service.AccountService;import com.itheima.util.ObjectFactory;public class TestTransfer {    /**     * @param args     * @throws Exception     */    public static void main(String[] args) throws Exception {        // AccountService as = new AccountServiceImpl();        // as.transfer("aaa", "bbb", 100);        AccountService as = ObjectFactory.getAccountService();        as.transfer("aaa", "bbb", 100);    }}/*package com.itheima.test;import com.itheima.service.AccountService;import com.itheima.service.impl.AccountServiceImpl;import com.itheima.util.ObjectFactory;public class TestTransfer {    public static void main(String[] args) throws Exception {        AccountService as = new AccountServiceImpl();        as.transfer("aaa", "bbb", 100);    }}*/

二、注解

注解不是注释，注释是程序员写的，给程序员看的。注解给程序看，用于描述程序如何运行及在什么阶段来运行。
现在在实际开发中，注解最大的功能是用于替换配置文件。

注解是jdk1.5的新特性。
可以通过反射来让注解具有功能。
注解格式： @Xxxx

2.1 JDK中的三个基本的注解：

? ? a. @Override ? 检查子类确实是覆盖了父类的方法。
? ? b. @Deprecated ? 说明已经过时了。
? ? c. @SuppressWarnings({ "unused", "deprecation", "rawtypes" }) ? 抑制程序中的警告。unused(变量未使用)、deprecation(过时)和rawtypes(泛型)表示警告的类型。{}数组。
? ? d. @SuppressWarnings("all")? all抑制所有警告。

? ? 示例代码如下：

package com.itheima.demo1;import java.util.ArrayList;import java.util.Date;import java.util.List;public class Demo1 {    // @SuppressWarnings({ "unused", "deprecation", "rawtypes" })     @SuppressWarnings("all")    public void ff() {        int i = 0;        System.out.println("abc");        List list = new ArrayList();        System.out.println(new Date().toLocaleString());    }    public void HaHa() {    }}class Demo2 extends Demo1 {    @Override    public void ff() {    }    @Deprecated    public void HaHaHa() {        System.out.println(new Date().toLocaleString());    }}

2.2 自定义注解的语法（注解的肉体）

? ? 研究一下注解的本质：
? ? ? ? 声明一个注解(或者创建一个注解类)： @interface 注解名｛…｝

public @interface MyAnnotation {}

? ? 通过反编译可知，注解它的本质就是一个接口，这个接口需要继承 Annotation接口。但是不能按照下述的代码格式写，需要按照上述代码格式写。

public interface MyAnnotation extends java.lang.annotation.Annotation {...}

? ? 分析注解类中的成员：
? ? ? ? 注解本质上就是接口，我们知道接口中可以有属性和方法。
? ? ? ? ? ? 属性：public static final int age;
? ? ? ? ? ? 方法：public abstract void show();

? ? ? ? 但是在注解中也可以有属性，也可以有方法。但是，注解中一般不使用属性。
? ? ? ? 在注解的开发中，我们只写方法。
? ? ? ? 我们管注解中的方法，叫做注解的属性。
? ? ? ? 在注解中我们管方法的返回值叫做注解的类型。
? ? ? ? ? ? 注解定义属性的格式 : 例如：int age();

? ? 关于注解的属性类型可以有哪些?
? ? ? ? 1. 基本类型
? ? ? ? 2. String
? ? ? ? 3. 枚举类型
? ? ? ? 4. 注解类型
? ? ? ? 5. Class类型
? ? ? ? 6. 以上类型的一维数组类型

? ? 注解：就是在你的程序代码中的某个位置加了一个标记而已。

? ?示例代码如下图所示：

2.3 注解的反射（注解的灵魂）

? ? 模拟 Junit 的 @Test 方法

? ?a、反射注解类
? ?java.lang.reflect.AnnotatedElement;
? ? ? < T extends Annotation > T getAnnotation(Class< T > annotationType) ? 得到指定类型的注解引用。没有，返回null。
? ? ? Annotation[] getAnnotations() ? 得到所有的注解，包含从父类继承下来的。
? ? ? Annotation[] getDeclaredAnnotations() ? 得到自己身上的注解。
? ? ? boolean isAnnotationPresent(Class< ? extends Annotation > annotationType) ? 判断指定的注解有没有。

? ? Class、Method、Field、Constructor等实现了AnnotatedElement接口。
? ? 例如：
? ? ? Class.isAnnotationPresent(MyTest.class); ? ? 判断类上面有没有@MyTest注解。
? ? ? Method.isAnnotationPresent(MyTest.class); ? ? 判断方法上面有没有@MyTest注解。

? ? b、反射注解中的属性
? ? 如下图元注解图片中所示：

2.4 元注解

? ? a、自定义注解的存活范围（生命周期）：默认是CLASS。


? ? 什么是元注解？ 答：只能用在注解类上的注解叫做元注解。（即：用于修饰注解的注解）

  • @Retention 作用：改变自定义注解的存活范围。
    ? RetentionPolicy
    ? ? SOURCE
    ? ? CLASS
    ? ? RUNTIME
    ? 例如：@Retention(RetentionPolicy.RUNTIME)
  • @Target 作用：指定该注解能用在什么地方。
    ? ElementType
    ? ? TYPE
    ? ? METHOD
    ? ? FIELD
    ? ? ANNOTATION_TYPE
    ? 例如：@Target({ ElementType.METHOD, ElementType.TYPE })
  • @Documented 作用：使用了@MyTest的注解的类，如果@MyTest注解类上面有@Documented注解，那么使用了@MyTest的注解的类的API文档中会出现@MyTest的身影。
  • @Inherited 作用：说明使用了该注解的类的子类可以继续使用该注解。

? ? 示例代码如下图所示：

三、简单介绍Servlet3.0中的几个注解

? ? 增加对注解的支持。
? ? ? Servlet3.0
? ? ? 要求：Tomcat7+ ? JDK6.0+

? ? Servlet3.0：web.xml已经不是必须的了。替代它的就是注解。


四、类加载器

? ? 1、作用：类加载器负责将 .class 文件(可能在磁盘上, 也可能在网络上) 加载到内存中, 并为之生成对应的 java.lang.Class。

? ? 2、JVM中的类加载器：（当 JVM 启动时，会形成由三个类加载器组成的初始类加载器层次结构： ）
? ? ? ? BootStrap：是老大。类加载器的祖先。 打印它会得到null。
? ? ? ? ? ? 负责加载 JRE/lib/rt.jar(JDK中绝大部分的类)
? ? ? ? ExtClassLoader：
? ? ? ? ? ? 负责加载 JRE/lib/ext/*.jar
? ? ? ? AppClassLoader：
? ? ? ? ? ? 负责加载在 classpath环境变量中的所有类
? ? 类加载器之间的父子关系图和管辖范围图


? ? 3、父类委托机制

? ? 示例代码：

package com.itheima;import javax.xml.crypto.dsig.keyinfo.KeyName;public class TestClassLoader {    public static void main(String[] args) {        // BootStrap：是老大。类加载器的祖先。 打印它会得到null。负责加载 JRE/lib/rt.jar(JDK中绝大部分的类)         ClassLoader cl = KeyName.class.getClassLoader();        System.out.println(cl); // null        // System.out.println(cl.getClass().getName()); // java.lang.NullPointerException        // ExtClassLoader： 负责加载 JRE/lib/ext/*.jar         // 没有找着可以测试的类，因为该目录下需要导入源码包，就没有测试啦！但是效果同AppClassLoader。        // AppClassLoader： 负责加载在 classpath环境变量中的所有类         ClassLoader cl1 = Student.class.getClassLoader();         System.out.println(cl1); // [email protected]        System.out.println(cl1.getClass().getName()); // sun.misc.Launcher$AppClassLoader    }}

? ? 示例图解01：


? ? 示例图解02：

原文地址：https://www.cnblogs.com/chenmingjun/p/9142660.html

时间： 2024-10-31 04:09:41

day19_java基础加强_动态代理+注解+类加载器的相关文章

Java进阶学习第24天——动态代理与类加载器

文档版本 开发工具 测试平台 工程名字 日期 作者 备注 V1.0 2016.06.17 lutianfei none 动态代理 代理对象存在的价值:主要用于拦截对真实业务对象的访问. 代理对象有什么方法? 现在要生成某一个对象的代理对象,这个代理对象通常也要编写一个类来生成,所以首先要编写用于生成代理对象的类. 如何编写生成代理对象的类,两个要素: 代理谁 如何生成代理对象 代理谁? 设计一个类变量,以及一个构造函数,记住代理类 代理哪个对象. 如何生成代理对象? 设计一个方法生成代理对象(在

学习Spring必学的Java基础知识(2)----动态代理

学习Spring必学的Java基础知识(2)----动态代理 引述要学习Spring框架的技术内幕,必须事先掌握一些基本的Java知识,正所谓“登高必自卑,涉远必自迩”.以下几项Java知识和Spring框架息息相关,不可不学(我将通过一个系列分别介绍这些Java基础知识,希望对大家有所帮助.): [1] Java反射知识-->Spring IoC :http://www.iteye.com/topic/1123081 [2] Java动态代理-->Spring AOP :http://www

Spring之AOP原理_动态代理

面向方面编程(Aspect Oriented Programming,简称AOP)是一种声明式编程(Declarative Programming).声明式编程是和命令式编程(Imperative Programming)相对的概念.我们平时使用的编程语言,比如C++.Java.Ruby.Python等,都属命令式编程.命令式编程的意思是,程序员需要一步步写清楚程序需要如何做什么(How to do What).声明式编程的意思是,程序员不需要一步步告诉程序如何做,只需要告诉程序在哪些地方做什么

由浅入深分析mybatis通过动态代理实现拦截器（插件）的原理

最近在用mybatis做项目,需要用到mybatis的拦截器功能,就顺便把mybatis的拦截器源码大致的看了一遍,为了温故而知新,在此就按照自己的理解由浅入深的理解一下它的设计. 和大家分享一下,不足和谬误之处欢迎交流.直接入正题. 首先,先不管mybatis的源码是怎么设计的,先假设一下自己要做一个拦截器应该怎么做.拦截器的实现都是基于代理的设计模式设计的,简单的说就是要创造一个目标类的代理类,在代理类中执行目标类的方法并拦截执行拦截器代码. 那么我们就用JDK的动态代理设计一个简单的拦截器

第17天（基础加强_注解_类加载器_动态代理）_学习目标版本

学习目标 能够使用Junit进行单元测试 能够说出注解的作用 能够使用JDK提供的3个注解 能够根据基本语法编写自定义注解实现类 能够了解自定义注解解析 能够了解元注解使用 能够根据上课案例分析,编写模拟@Test案例 能够理解动态代理原理 能够使用动态代理Proxy编写代理类 Junit单元测试 Junit介绍 JUnit是一个Java语言的单元测试框架,简单理解为可以用于取代java的main方法.Junit属于第三方工具,一般情况下需要导入jar包,不过,多数Java开发环境已经集成了JU

注解 、 动态代理、类加载

单元测试 @Test eclipse自带jar包 Ctrl+1导入使用 注解 JDK提供的注解 @Deprecated 表示被修饰的方法已经过时 @Override 重写方法 1.5支持父类不支持接口 1.5之后支持接口 @SuppressWarnings 抑制警告 需要给属性值 all 所有的警告都被抑制 ({    }) "unused" 没有使用警告 "rawtypes" 类型不安全警告 "unchecked" 使用不安全 安全检查 &qu

JAVA基础_动态代理的基本API

JDK动态代理 代理类中使用的方法需要声明在接口中 需要得到目标类的对象 Cglib包中的动态代理 import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import org.junit.Test; import java.lang.reflect.InvocationHandler; import java.l

mybatis基础_动态代理开发

1.使用原始dao开发需要编写mapper的接口和实现类 1.编写接口 public interface UserDao { User getUserById(int userId); } 2.编写实现类 public class UserDaoImpl implements UserDao { private SqlSessionFactory sqlSessionFactory; public UserDaoImpl(SqlSessionFactory sqlSessionFactory)

Spring AOP基础之JDK动态代理

JDK动态代理 Jdk动态代理是装饰模式的一个典型用例,关于装饰模式这里不多解释,直接说重点吧.jdk动态代理实际上就是代替继承方案,在不破坏原始类的原则下,在运行期间为某个类动态注入一些新的方法.java.lang.reflect.Proxy提供了生成代理类的接口.进入源代码,我们可以看见关于Proxy的详细说明这里截取一些关键的部分: /** * {@code Proxy} provides static methods for creating dynamic proxy * classe