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:当前方法用到的参数。
动态代理的应用
:
- 在动态代理技术里,由于不管用户调用代理对象的什么方法,都是调用开发人员编写的处理器的invoke方法(这相当于
invoke方法拦截到了被代理对象的方法调用
)。 - 并且,开发人员通过invoke方法的参数,还可以在拦截的同时,知道用户调用的是什么方法,因此利用这两个特性,就可以实现一些特殊需求,例如:拦截用户的访问请求,以检查用户是否有访问权限、动态地为目的对象添加额外的功能。
动态代理模式简单案例:
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);
}
}
静态/动态代理图解:
![](https://s1.ax1x.com/2018/12/11/FYMOfg.png)
1.3、AOP(面向切面编程)编程思想(Spring框架中的核心思想之一)
Spring框架中的核心思想包括:
Dependency Injection(依赖注入
)
Inverse of Control(控制反转
)
Aspect Oriented Programming(面向切面编程
)
AOP编程思想解决的问题:
1、问题:业务的方法日后会很多,这样会有很多重复的代码。
2、问题:业务已经存在很多的方法,并没有考虑到事务的问题,现在要求加上。那么业务的重心就变了。
![](https://s1.ax1x.com/2018/12/11/FYMHTf.png)
动态代理实现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 {
/**
* @param args
* @throws Exception
*/
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、以上类型的一维数组类型
注解:就是在你的程序代码中的某个位置加了一个标记
而已。
示例代码如下图所示:
![](https://s1.ax1x.com/2018/12/11/FYMqk8.png)
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。
![](https://s1.ax1x.com/2018/12/11/FYMLtS.png)
什么是
元注解
? 答:只能用在注解类上的注解叫做元注解。(即:用于修饰注解的注解
)
-
@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
作用:说明使用了该注解的类的子类可以继续使用该注解。
示例代码如下图所示:
![](https://s1.ax1x.com/2018/12/11/FYM70P.png)
三、简单介绍Servlet3.0中的几个注解
增加对注解的支持。
Servlet3.0
要求:Tomcat7+ 和 JDK6.0+
Servlet3.0:web.xml已经不是必须的了。替代它的就是注解。
![](https://s1.ax1x.com/2018/12/11/FYMjpQ.png)
截图如下:
![](https://s1.ax1x.com/2018/12/11/FYMx6s.png)
四、类加载器
1、作用:类加载器负责将 .class 文件(可能在磁盘上
, 也可能在网络上
) 加载到内存中, 并为之生成对应的 java.lang.Class。
2、JVM中的类加载器:(当 JVM 启动时,会形成由三个类加载器组成的初始类加载器层次结构: )
BootStrap:是老大。类加载器的祖先。 打印它会得到null。
负责加载 JRE/lib/rt.jar
(JDK中绝大部分的类)
ExtClassLoader:
负责加载 JRE/lib/ext/*.jar
AppClassLoader:
负责加载在 classpath环境变量中的所有类
类加载器之间的父子关系图和管辖范围图;
![](https://s1.ax1x.com/2018/12/11/FYMvlj.png)
3、父类委托机制(全盘负责委托机制 )
例如:用eclipse的打包工具将TestClassLoader输出成jre/lib/ext目录下的itcast.jar包,再在eclipse中运行这个类,运行结果显示为ExtClassLoadr。此时的环境状态是classpath目录有TestClassLoader.class,ext/itcast.jar包中也有TestClassLoader.class,我们知道,使用一个类,应该只出现一个字节码文件,现在却出现两个了,肿么办?这时候我们就需要了解类加载的具体过程和原理了。如下所示:
- bootstrap classloader:
引导(也称为原始)类加载器
,它负责加载Java的核心类。这个加载器是非常特殊的,它实际上不是java.lang.ClassLoader的子类,而是由JVM自身实现的(底层是c代码)。因为JVM在启动的时候就自动加载它们,所以不需要在系统属性CLASSPATH中指定这些类库。 - extension classloader:
扩展类加载器
,它负责加载JRE的扩展目录(JAVA_HOME/jre/lib/ext或者由java.ext.dirs系统属性指定的)中的JAR包。这为引入除Java核心类以外的新功能提供了一个标准机制。因为默认的扩展目录对所有从同一个JRE中启动的JVM都是通用的,所以放入这个目录的JAR类包对所有的JVM和system classloader都是可见的。 - system classloader:
系统(也称为应用)类加载器
,它负责在JVM被启动时,加载来自在命令java中的-classpath或者java.class.path系统属性或者CLASSPATH操作系统属性所指定的JAR类包和类路径。可以通过静态方法ClassLoader.getSystemClassLoader();
找到该类加载器。如果没有特别指定,则用户自定义的任何类加载器都将该类加载器作为它的父加载器。
- classloader 加载类用的是
全盘负责委托机制
。 全盘负责
:即是当一个classloader加载一个Class的时候,这个Class所依赖的和引用的其它Class通常
也由这个classloader负责载入。委托机制
:先让parent(父)类加载器 寻找,只有在parent找不到的时候才从自己的类路径中去寻找。- 类加载还采用了
cache机制
:如果cache中保存了这个Class就直接返回它,如果没有才从文件中读取和转换成Class,并存入cache,这就是为什么修改了Class但是必须重新启动JVM才能生效,并且类只加载一次的原因
。
![](https://s1.ax1x.com/2018/12/11/FYMzXn.png)
示例代码:
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:
![](https://s1.ax1x.com/2018/12/11/FYQikT.png)
示例图解02:
![](https://s1.ax1x.com/2018/12/11/FYQC7V.png)
【转载文章务必保留出处和署名,谢谢!】