一、动态代理

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：当前方法用到的参数。

动态代理模式简单案例：

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

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");
    }
}

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);
    }
}

静态/动态代理图解：

day19_java基础加强_动态代理+注解+类加载器一、动态代理二、注解三、简单介绍Servlet3.0中的几个注解四、类加载器

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); // sun.misc.Launcher$AppClassLoader@73d16e93
        System.out.println(cl1.getClass().getName()); // sun.misc.Launcher$AppClassLoader
    }
}

示例图解01：

示例图解02：

我的GitHub地址：

https://github.com/heizemingjun

我的博客园地址：

http://www.cnblogs.com/chenmingjun

我的蚂蚁笔记博客地址：

http://blog.leanote.com/chenmingjun

【转载文章务必保留出处和署名，谢谢！】

day19_java基础加强_动态代理+注解+类加载器一、动态代理二、注解三、简单介绍Servlet3.0中的几个注解四、类加载器

一、动态代理

1.1、代理模式

1.2、动态代理

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

二、注解

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

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

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

2.4 元注解

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

四、类加载器

继续阅读

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

面试题解析：你接口测试是怎么做的？

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method

day19_java基础加强_动态代理+注解+类加载器一、动态代理二、注解三、简单介绍Servlet3.0中的几个注解四、类加载器

一、动态代理

1.1、代理模式

1.2、动态代理

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

二、注解

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

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

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

2.4 元注解

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

四、类加载器

继续阅读

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