一、动态代理
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();
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
public void transfer(String fromname, String toname, double money) throws Exception {
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);
ad.updateAccout(toAccount);
}
}
产生代理对象的工厂代码：
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 {
public static void main(String[] args) throws Exception {
AccountService as = ObjectFactory.getAccountService();
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("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) {
ClassLoader cl = KeyName.class.getClassLoader();
System.out.println(cl);
ClassLoader cl1 = Student.class.getClassLoader();
System.out.println(cl1);
System.out.println(cl1.getClass().getName());
}
}
示例图解01：
![]()
示例图解02：
![]()
