一、動態代理
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);
}
}
靜態/動態代理圖解：
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 {
/**
* @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、以上類型的一維數組類型
注解：就是在你的程序代碼中的某個位置加了一個標記而已。
示例代碼如下圖所示：
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、父類委托機制（全盤負責委托機制 ）
例如：用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才能生效，並且類只加載一次的原因。
示例代碼：
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：
