靜態代理java
『壹』 java靜態代理和裝飾模式的區別
裝飾模式：以對客戶端透明的方式擴展對象的功能，是繼承關系的一個替代方案；
代理模式：給一個對象提供一個代理對象，並有代理對象來控制對原有對象的引用；
裝飾模式應該為所裝飾的對象增強功能；代理模式對代理的對象施加控制，並不提供對象本身的增強功能
二者的實現機制確實是一樣的，可以看到他們的實例代碼重復是很多的。但就語義上說，這兩者的功能是相反的，模式的一個重要作用是簡化其他程序員對你程序的理解，你在一個地方寫裝飾，大家就知道這是在增加功能，你寫代理，大家就知道是在限制。
『貳』 什麼是java代理模式，具體相關的動態代理和靜態代理分別是什麼舉例更好啦~
簡單的例子: HelloSpeaker.java
import java.util.logging.*;
public class HelloSpeaker {
private Logger logger = Logger.getLogger(this.getClass().getName());
public void hello(String name) {
logger.log(Level.INFO, "hello method starts...."); //日誌記錄
System.out.println("Hello, " + name); //!!!!!!!!!!!
logger.log(Level.INFO, "hello method ends...."); //日誌記錄
}
}
HelloSpeaker在執行hello()方法時，我們希望能記錄該方法已經執行以及結束，
最簡單的作法就是如上在執行的前後加上記錄動作，然而Logger介入了HelloSpeaker中，
記錄這個動作並不屬於HelloSpeaker，這使得HelloSpeaker的職責加重。
------------------------------------------------------------------------------------------
怎麼辦，用下面的方法或許好一些:
先定義一個介面:
public interface IHello {
public void hello(String name);
}
------------------------------------------------------------------------------------------
實現該介面
public class HelloSpeaker implements IHello {
public void hello(String name) {
System.out.println("Hello, " + name);
}
}
public class Greeting implements IHello{
public void hello(String name){
System.out.println("Greeting, " + name);
}
}
------------------------------------------------------------------------------------------
實現一個代理對象: HelloProxy
import java.util.logging.*;
public class HelloProxy implements IHello {
private Logger logger = Logger.getLogger(this.getClass().getName());
private IHello helloObject; //被代理對象
public HelloProxy(){}
public HelloProxy(IHello helloObject) {
this.helloObject = helloObject; //把被代理對象傳入
}
public void setHelloObject(IHello helloObject){
this.helloObject = helloObject;
}
public IHello getHelloObject(){
return this.helloObject;
}
public void hello(String name) {
logger.log(Level.INFO, "hello method starts...."); //日誌記錄
helloObject.hello(name); //!!!!!!!!調用被代理對象的方法
logger.log(Level.INFO, "hello method ends...."); //日誌記錄
}
}
-----------------------------------------------------------------------------------------------------
執行:
IHello helloProxy = new HelloProxy(new HelloSpeaker()); //生成代理對象, 並給它傳入一個被代理的對象
helloProxy.hello("world");
//IHello h=factory.getBean("hello"); // IoC
//h.hello("world");
IHello helloProxy = new HelloProxy(new Greeting()); //生成代理對象, 並給它傳入一個被代理的對象
helloProxy.hello("world");
-----------------------------------------------------------------------------------------------------
代理對象HelloProxy將代理真正的HelloSpeaker來執行hello()，並在其前後加上記錄的動作，
這使得我們的HelloSpeaker在寫時不必介入記錄動作，HelloSpeaker可以專心於它的職責。
這是靜態代理的基本範例，然而，代理對象的一個介面只服務於一種類的對象，而且如果要代理的方法很多，
我們勢必要為每個方法進行代理，靜態代理在程序規模稍大時就必定無法勝任.
Java在JDK 1.3之後加入協助開發動態代理功能的類，我們不必為特定對象與方法寫特定的代理，使用動態代理，
可以使得一個handler服務於各個對象，首先，一個handler必須實現java.lang.reflect.InvocationHandler：
import java.util.logging.*;
import java.lang.reflect.*;
public class LogHandler implements InvocationHandler { //
private Logger logger = Logger.getLogger(this.getClass().getName());
private Object delegate; //被代理的對象
public Object bind(Object delegate) { //自定義的一個方法，用來綁定被代理對象的，返回值為被代理方法的返回值
this.delegate = delegate;
return Proxy.newProxyInstance(
delegate.getClass().getClassLoader(),
delegate.getClass().getInterfaces(),
this); //通過被代理的對象生成它的代理對象, 並同handler綁定在一起
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try {
logger.log(Level.INFO, "method starts..." + method); //日誌記錄
result = method.invoke(delegate, args); //!!!!!!!!調用被代理對象的方法
logger.log(Level.INFO, "method ends..." + method); //日誌記錄
} catch (Exception e){
logger.log(Level.INFO, e.toString());
}
return result;
}
}
InvocationHandler的invoke()方法會傳入被代理對象的方法名稱與參數, 實際上要執行的方法交由method.invoke()，
並在其前後加上記錄動作，method.invoke()返回的對象是實際方法執行過後的回傳結果。
動態代理必須有介面:
public interface IHello {
public void hello(String name);
}
實現該介面:
public class HelloSpeaker implements IHello {
public void hello(String name) {
System.out.println("Hello, " + name);
}
}
執行:
LogHandler logHandler = new LogHandler();
IHello helloProxy = (IHello) logHandler.bind(new HelloSpeaker()); //傳入被代理對象, 傳回代理對象
helloProxy.hello("Justin");
『叄』 Java中的動態代理相對於靜態代理有何優點
缺Java中的動態代理相對於靜態代理優點:
1、靜態代理類和委託類實現了相同的介面，代理類通過委託類實現了相同的方法。這樣就出現了大量的代碼重復。如果介面增加一個方法，除了所有實現類需要實現這個方法外，所有代理類也需要實現此方法。增加了代碼維護的復雜度。
2、靜態代理對象只服務於一種類型的對象，如果要服務多類型的對象。勢必要為每一種對象都進行代理，靜態代理在程序規模稍大時就無法勝任了。如上的代碼是只為UserManager類的訪問提供了代理，但是如果還要為其他類如Department類提供代理的話，就需要我們再次添加代理Department的代理類。
『肆』 java下SpringMVC中Spring的主要工作原理是什麼是怎麼工作的工作流程是什麼
一、 IoC(Inversion of control): 控制反轉 x0dx0a1、IoC： x0dx0a概念：控制權由對象本身轉向容器；由容器根據配置文件去創建實例並創建各個實例之間的依賴關系 x0dx0a核心：bean工廠；在Spring中，bean工廠創建的各個實例稱作bean x0dx0a二、AOP(Aspect-Oriented Programming): 面向方面編程 x0dx0a1、 代理的兩種方式： x0dx0a靜態代理： x0dx0a 針對每個具體類分別編寫代理類； x0dx0a 針對一個介面編寫一個代理類； x0dx0a動態代理： x0dx0a針對一個方面編寫一個InvocationHandler，然後借用JDK反射包中的Proxy類為各種介面動態生成相應的代理類 x0dx0a2、 AOP的主要原理：動態代理 x0dx0ax0dx0aSpring工作原理 x0dx0a Spring 已經用過一段時間了，感覺Spring是個很不錯的框架。內部最核心的就是IOC了， x0dx0a動態注入，讓一個對象的創建不用new了，可以自動的生產，這其實就是利用java里的反射 x0dx0a反射其實就是在運行時動態的去創建、調用對象，Spring就是在運行時，跟xml Spring的配置 x0dx0a文件來動態的創建對象，和調用對象里的方法的 。 x0dx0a Spring還有一個核心就是AOP這個就是面向切面編程，可以為某一類對象 進行監督和控制（也就是 x0dx0a在調用這類對象的具體方法的前後去調用你指定的 模塊）從而達到對一個模塊擴充的功能。這些都是通過 x0dx0a配置類達到的。 x0dx0a Spring目的：就是讓對象與對象（模塊與模塊）之間的關系沒有通過代碼來關聯，都是通過配置類說明 x0dx0a管理的（Spring根據這些配置 內部通過反射去動態的組裝對象） x0dx0a 要記住：Spring是一個容器，凡是在容器里的對象才會有Spring所提供的這些服務和功能。 x0dx0aSpring里用的最經典的一個設計模式就是：模板方法模式。（這里我都不介紹了，是一個很常用的設計模式） x0dx0a Spring里的配置是很多的，很難都記住，但是Spring里的精華也無非就是以上的兩點，把以上兩點跟理解了 x0dx0a也就基本上掌握了Spring.
『伍』 Java靜態代理和iOS代理模式這兩個概念的理解上的疑惑
看了JAVA版的設計模式的 代理模式 和IOS @protrol 比較，java 的看了都暈了。不完全一致，委託和代理 稱呼上就好像反的。用JAVA 的中介面 在view中實現方法，就要把介面中所有的方法都復寫一下，這個不太好用， 還不知道其它什麼模式來實現像Ios @protrol 的功能。
『陸』 Java軟體工程師一般要上哪些課程
Java軟體工程師應學習課程大致如下：
1、軟體技術基礎、java基礎編程、java語法，SQL Server 2005基礎編程、C#基礎編程；
8、企業流行框架：Struts、Sring、Hibernate、XML應用與開發、MVC應用與開發、Linux平台與應用；
9 、UML與Java設計模式；
10、了解在Java項目中使用的新技術。如Ajax、java ee等。
『柒』 java靜態代理與動態代理的區別
動態代理IP和靜態代理IP有什麼區別
代理ip從ip的撥號方式來區分，分為動態ip和靜態ip，所以代理ip也分為動態代理ip和靜態代理ip。實際上靜態數據的ip是較為普遍的，它一般是不容易變的，並且有效期限也較為長，僅僅動態代理IP大家很有可能會出現大量的疑惑，那麼，到底靜態數據ip和動態性ip代理關鍵有什麼差別呢？
1、ip是不是變化
靜態數據和動態性最關鍵的一個差別便是，靜態數據的ip是不容易變的，而動態ip是會動態更新的，並且動態性的及時性是很短的。靜態數據ip一般會按天、周和月測算，而動態ip是按分鍾測算的，最多也就半小時。
3、應用情景不一樣
動態代理IP和靜態數據ip的應用情景是不一樣的，一般靜態數據ip僅僅在賬戶登錄、微信養號或者用以網游工作室等情景應用。可是動態ip的應用范疇會更為普遍，無論是網上投票，還是數據收集，及其數據挖掘等全是能夠應用的。
了解了動態代理IP和靜態IP的差別以後，客戶能夠依據自身的要求，更為精確的作出挑選，也可以防止對動態ip不足掌握，而不正確挑選，導致損害的狀況。這是兩種常見的IP代理形式。根據您的實際需要選擇相應的IP地址替換方法。IPIDEA全球IP代理可以幫助你更好的接入和運營網路。
『捌』 Java動態代理與靜態代理的定義與區別
JAVA的靜態代理與動態代理比較
一、概念
代理模式是常用的Java 設計模式，它的特徵是代理類與委託類有同樣的介面，代理類主要負責為委託類預處理消息、過濾消息、把消息轉發給委託類，以及事後處理消息等。代理類與委託類之間通常會存在關聯關系，一個代理類的對象與一個委託類的對象關聯，代理類的對象本身並不真正實現服務，而是通過調用委託類的對象的相關方法，來提供特定的服務。按照代理類的創建時期，代理類可分為兩種。
靜態代理類：
由程序員創建或由特定工具自動生成源代碼，再對其編譯。在程序運行前，代理類的.class文件就已經存在了。動態代理類：在程序運行時，運用反射機制動態創建而成。
二、靜態代理類
如下， HelloServiceProxy 類是代理類，HelloServiceImpl類是委託類，這兩個類都實現了HelloService介面。其中HelloServiceImpl類是HelloService介面的真正實現者，而HelloServiceProxy類是通過調用HelloServiceImpl 類的相關方法來提供特定服務的。HelloServiceProxy類的echo()方法和getTime()方法會分別調用被代理的HelloServiceImpl 對象的echo()方法和getTime()方法，並且在方法調用前後都會執行一些簡單的列印操作。
由此可見，代理類可以為委託類預處理消息、把消息轉發給委託類和事後處理消息等。
常式1 HelloService.java
package proxy;
import java.util.Date;
public interface HelloService{
public String echo(String msg);
public Date getTime();
}
常式2 HelloServiceImpl.java
package proxy;
import java.util.Date;
public class HelloServiceImpl implements HelloService{
public String echo(String msg){
return "echo:"+msg;
}
public Date getTime(){
return new Date();
}
}
常式3 HelloServiceProxy.java
package proxy;
import java.util.Date;
public class HelloServiceProxy implements HelloService{
private HelloService helloService; //表示被代理的HelloService 實例
public HelloServiceProxy(HelloService helloService){
this.helloService=helloService;
}
public void setHelloServiceProxy(HelloService helloService){
this.helloService=helloService;
}
public String echo(String msg){
System.out.println("before calling echo()"); //預處理
String result=helloService.echo(msg); //調用被代理的HelloService 實例的echo()方法
System.out.println("after calling echo()"); //事後處理
return result;
}
public Date getTime(){
System.out.println("before calling getTime()"); //預處理
Date date=helloService.getTime(); //調用被代理的HelloService 實例的getTime()方法
System.out.println("after calling getTime()"); //事後處理
return date;
}
}
在Client1 類的main()方法中，先創建了一個HelloServiceImpl對象，又創建了一個HelloServiceProxy對象，最後調用HelloServiceProxy對象的echo()方法。
常式4 Client1.java
package proxy;
public class Client1{
public static void main(String args[]){
HelloService helloService=new HelloServiceImpl();
HelloService helloServiceProxy=new HelloServiceProxy(helloService);
System.out.println(helloServiceProxy.echo("hello"));
}
}
運行Client1 類，列印結果如下：
before calling echo()
after calling echo()
echo:hello
常式3 的HelloServiceProxy 類的源代碼是由程序員編寫的，在程序運行前，它的.class文件就已經存在了，這種代理類稱為靜態代理類。
三、動態代理類
與靜態代理類對照的是動態代理類，動態代理類的位元組碼在程序運行時由Java反射機制動態生成，無需程序員手工編寫它的源代碼。動態代理類不僅簡化了編程工作，而且提高了軟體系統的可擴展性，因為Java 反射機制可以生成任意類型的動態代理類。java.lang.reflect 包中的Proxy類和InvocationHandler 介面提供了生成動態代理類的能力。
Proxy類提供了創建動態代理類及其實例的靜態方法。
（1）getProxyClass()靜態方法負責創建動態代理類，它的完整定義如下：
public static Class<?> getProxyClass(ClassLoader loader, Class<?>[] interfaces) throws IllegalArgumentException
參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面。
（2）newProxyInstance()靜態方法負責創建動態代理類的實例，它的完整定義如下：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) throws
IllegalArgumentException
參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面，參數handler 指定與動態代理類關聯的 InvocationHandler 對象。
以下兩種方式都創建了實現Foo介面的動態代理類的實例：
/**** 方式一 ****/
//創建InvocationHandler對象
InvocationHandler handler = new MyInvocationHandler(...);
//創建動態代理類
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), new Class[] { Foo.class });
//創建動態代理類的實例
Foo foo = (Foo) proxyClass.getConstructor(new Class[] { InvocationHandler.class }).
newInstance(new Object[] { handler });
/**** 方式二 ****/
//創建InvocationHandler對象
InvocationHandler handler = new MyInvocationHandler(...);
//直接創建動態代理類的實例
Foo foo = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[] { Foo.class }, handler);
由Proxy類的靜態方法創建的動態代理類具有以下特點：
動態代理類是public、final和非抽象類型的；
動態代理類繼承了java.lang.reflect.Proxy類；
動態代理類的名字以「$Proxy」開頭；
動態代理類實現getProxyClass()和newProxyInstance()方法中參數interfaces指定的所有介面；
Proxy 類的isProxyClass(Class<?> cl)靜態方法可用來判斷參數指定的類是否為動態代理類。只有通過Proxy類創建的類才是動態代理類；
動態代理類都具有一個public 類型的構造方法，該構造方法有一個InvocationHandler 類型的參數。
由Proxy類的靜態方法創建的動態代理類的實例具有以下特點：
1. 假定變數foo 是一個動態代理類的實例，並且這個動態代理類實現了Foo 介面，那麼「foo instanceof Foo」的值為true。把變數foo強制轉換為Foo類型是合法的：
(Foo) foo //合法
2.每個動態代理類實例都和一個InvocationHandler 實例關聯。Proxy 類的getInvocationHandler(Object proxy)靜態方法返回與參數proxy指定的代理類實例所關聯的InvocationHandler 對象。
3.假定Foo介面有一個amethod()方法，那麼當程序調用動態代理類實例foo的amethod()方法時，該方法會調用與它關聯的InvocationHandler 對象的invoke()方法。
InvocationHandler 介面為方法調用介面，它聲明了負責調用任意一個方法的invoke()方法：
Object invoke(Object proxy,Method method,Object[] args) throws Throwable
參數proxy指定動態代理類實例，參數method指定被調用的方法，參數args 指定向被調用方法傳遞的參數，invoke()方法的返回值表示被調用方法的返回值。
四、最後看一個實例：
HelloServiceProxyFactory 類的getHelloServiceProxy()靜態方法負責創建實現了HelloService介面的動態代理類的實例。
常式5 HelloServiceProxyFactory.java
package proxy;
import java.lang.reflect.*;
public class HelloServiceProxyFactory {
/** 創建一個實現了HelloService 介面的動態代理類的實例
* 參數helloService 引用被代理的HelloService 實例
*/
public static HelloService getHelloServiceProxy(final HelloService helloService){
//創建一個實現了InvocationHandler介面的匿名類的實例
InvocationHandler handler=new InvocationHandler(){
public Object invoke(Object proxy,Method method,Object args[])throws Exception{
System.out.println("before calling "+method); //預處理
Object result=method.invoke(helloService,args);
//調用被代理的HelloService 實例的方法
System.out.println("after calling "+method); //事後處理
return result;
}
};
Class classType=HelloService.class;
return (HelloService)Proxy.newProxyInstance(classType.getClassLoader(),
new Class[]{classType},
handler);
}
}
如下所示的Client2 類先創建了一個HelloServiceImpl 實例，然後創建了一個動態代理類實例helloServiceProxy，最後調用動態代理類實例的echo()方法。
常式6 Client2.java
package proxy;
public class Client2{
public static void main(String args[]){
HelloService helloService=new HelloServiceImpl();
HelloService helloServiceProxy=HelloServiceProxyFactory.getHelloServiceProxy(helloService);
System.out.println("動態代理類的名字為"+helloServiceProxy.getClass().getName());
System.out.println(helloServiceProxy.echo("Hello"));
}
}
運行Client2，列印結果如下：
動態代理類的名字為$Proxy0
before calling public abstract java.lang.String proxy.HelloService.echo(java.lang.String)
after calling public abstract java.lang.String proxy.HelloService.echo(java.lang.String)
echo:Hello
從結果看出，動態代理類的名字為$Proxy0。
『玖』 Java軟體工程師一般要學習哪些課程
Java 是一門 c 語言，所以學習 c 語言對你學習 java 很有幫助，但是這並不意味著你不學習 c 語言就不能學習 java 仍然是相對有希望的，薪水也不錯，一般本科學位可以達到2500-3000，高級程序員可以達到10000。(具體來說，客戶機層是3000，表示層是5000，業務邏輯層是8000，持久層是大約10,000。)Java 的東西很零散，但是學起來並不難，只要你真的想進入這個行業。你現在只需要學習 java 的基礎知識，如果你想擴展，你必須學習你在樓上談論的東西，賺錢的主要方法是使用 javaee，它的 harbnet，spring，ejb 等等。表示層是用戶在使用產品時看到的界面或頁面(jsp 是 web 頁面) ，業務邏輯層是用戶需要添加到其中的業務邏輯(即完成用戶的功能) ，持久層是持久化到資料庫的所有業務邏輯。
VA是一種可以撰寫跨平台應用軟體的面向對象的程序設計語言，是由SUN公司推出的JAVA程序設計語言和JAVA平台的總稱，JAVA應用主要由四大方向：JAVA桌面應用、WEB應用、企業級應用和嵌入式應用，具體點能幹什麼呢？如：Hadoop大數據處理、Android 開發、伺服器開發、網站、軟體開發工具、自然語言處理等等。
Java軟體工程師主要學習：
首先，無論你以後從事Java的那個方向，web後台開發還是Andrio開發，那麼你都需要先學習Java的基礎知識。比如8種數據結構，String的常用方法，流程式控制制語句等基礎知識。這些基礎知識的學習可以去查找相關資料，也可以報課程學習。
其次，當掌握了基礎知識之後，你需要學習java的進階知識，進階包括多線程、反射、過濾器、監聽器、連接池、事務、靜態代理、動態代理等相關技術。那麼高級就需要學習JAVA的內存模型，虛擬機，以及Java源碼等，這個階段很多都需要根據項目實戰來進行加深理解。如果是自學，很難接觸到市場上真實的實戰項目。
由於java應用面比較廣，可以用來做行業軟體、互聯網軟體以及大數據等軟體的開發。後面要根據自己想做的方向去學習java在這個方向的主要框架，針對這些框架去學習。例如用於行業OA以及ERP的框架SSH和Spring MVC。用於互聯網後台的框架SpringBoot微服務以及SpringCloud框架。大數據分Hadoop框架，自己storm的流式處理框架。
JAVA是目前全世界最廣泛最實用的編程語言，JAVA本身的分類很多，如果要全部掌握，需要大量的時間。Java的發展前景目前來講還是非常不錯的，在國內的用人需求及薪資都很高。
有對Java感興趣的同學就趕快學習起來吧，既然選擇要學Java語言現在就去做，現在永遠比未來早。時不等人，抓緊時間開始學習之旅吧。學習沒有捷徑，希望大家都能少走一些彎路，在學習Java的道路上一往無前，學有所成！
『拾』 Java培訓課程有哪些
一般來說Java培訓課程有8個階段，你可以按照Java路線圖的順序學習，選擇Java培訓機構重點關注機構的口碑情況，除了口碑再了解機構的師資、課程、就業、費用等等方面，多對幾家機構，希望你早日學有所成。