java注入類_如何通俗的理解java的依賴注入

『壹』什麼是注入類、宿主類（java）

注入類是被引用的類，宿主類應該是引用注入類的類。一般用XML文件或Annotation調用，ejb3.0是使用這個比較多的框架，用這個就不用傳統的jndi了，其實原理是一樣的，只是現在的架構給封裝好了。好像是叫IOC模式，比較好用，可以省些代碼，不過引用的注入類必須是受容器管制類。

『貳』 javaee中的類想要注入到springmvc中如何做

指使用反射相於我自編寫spring框架使用反射根據位元組碼class文件態java類象即創建實例實例象交給想給controll類概思路 ------希望採納畢竟我純手

『叄』 java在抽象類中注入屬性架構設計

題主是在用spring做注入？

抽象類是可以用spring注入屬性的。我的代碼中有個這樣的例子：
<bean id="BaseEventAction" class="com.sinosig.evaluation.fcff.web.event.BasicEventAction"
abstract="true" parent="BaseAction">
<property name="rowFactory" ref="FcffCacheAdapter" />
<property name="caculate" ref="CaculateService" />
<property name="diffusion" ref="DeffusionService" />
</bean>

<bean id="MethodChangedAction"
class="com.sinosig.evaluation.fcff.web.event.MethodChagedAction"
scope="prototype" parent="BaseEventAction" />

public abstract class BasicEventAction extends BaseAction implements
EventAction {

……

}

public class MethodChagedAction extends BasicEventAction {
……

}

spring框架中的 abstract="true" 是告訴spring框架不要去實例化這個類而已。但是在spring的配置中，仍然會有相關的注入屬性的配置。子類的配置會繼承父類的配置，然後spring框架再根據子類的最終配置去實例化和注入。

『肆』 java循環注入的問題該怎麼解決

加AOP能解決spring IoC的循環引用。

循環引用是你配置bean的時候，構建方式上出了錯。比如，創建A對象的時候，你引用到了B，而創建B對象的時候，你又引用到了A。你仔細檢查下你的構造器

循環依賴——在採用構造器注入的方式配置bean時，很有可能會產生循環依賴的情況。比如說，一個類A，需要通過構造器注入類B，而類B又需要通過構造器
注入類A。如果為類A和B配置的bean被互相注入的話，那麼Spring IoC容器將檢測出循環引用，並拋出

異常。對於此問題，一個可能的解決方法就是修改源代碼，將某些構造器注入改為

setter注入。另一個解決方法就是完全放棄構造器注入，只使用setter注入。換句話說，除了極少數例外，大部分的循環依賴都是可以避免的，不過採用setter注入產生循環依賴的可能性也是存在的。與通常我們見到的非循環依賴的情況有所不同，在兩個bean之間的循環依賴將導致一個bean在被完全初始化的時候被注入到另一個bean中。

『伍』 java怎麼實現像spring那樣讀取配置文件然後注入到類的屬性中

用反射就可以了 spring也是基於反射的
解析xml 根據類路徑得到class(Class.forName) 然後根據你給的property通過getField拿到Field
再實例化再賦值

『陸』求JAVA 注入進程的例子

此代碼注入非依賴注入，是hack里的代碼注入

場景是這樣滴：

機器上有一個java進程，我不想停止它，但我想把一段代碼植入進去，干

一些事情（獲取一些信息，改變一些值，監控一些東西，或者其它猥瑣的事情）

這個進程不能停，而且也沒有預料到現在的事情，或者這個進程的代碼完全不能修改。

好，這篇文章是要干這個事情，它基於jvm的jdi或者jvmti介面

這里用的jvmti,jdi也可以，麻煩不少

應該jdk1.5就有，需要用c寫。1.6支持另一種方式，java也可以寫

以前做過類似的事情，代碼找不到了，現在有實現了一番。

直接上代碼：

被注入的代碼是這樣滴：

while(true) {
    System.out.println(System.currentTimeMillis());
    Thread.sleep(1000);
}

每隔一秒輸出當前時間，只是示意用。不管什麼java程序都行

我要注入的類，那個方法是固定的：

package com.zms.inject;
import java.lang.instrument.Instrumentation;
public class MyAgent1 {
    public static void premain(String s) {
        premain(s, null);
    }
    public static void premain(String s, Instrumentation instru) {
        System.out.println("I'm injected! 木哈哈哈哈哈");
        System.out.printf("param: %s
", s);
    }
    public static void agentmain(String args, Instrumentation inst) {
        premain(args, inst);
    }
    public static void agentmain(String args) {
        premain(args);
    }
}

編譯，打入jar包

MANIFEST.MF

Manifest-Version:1.0

Created-By:1.6.0_26(AppleInc.)

Agent-Class:com.zms.inject.MyAgent1

Premain-Class:com.zms.inject.MyAgent1

操作代碼：

import com.sun.tools.attach.*;
import com.sun.tools.attach.spi.AttachProvider;
VirtualMachine vm=VirtualMachine.attach("24862");  //target java process pid
System.out.println(vm);
vm.loadAgent("/Users/zms/workspace/mt/out/proction/agent1.jar","Powered by zms!");
Thread.sleep(1000);
vm.detach();

目標程序結果：

1317283652520

1317283653520

1317283654521

I'minjected!木哈哈哈哈哈

param:Poweredbyzms!

1317283655521

1317283656522

『柒』如何利用Java實現資源注入

Java的功能強大，今兒博洋教育將給大家介紹。需求：一個應用有兩個資料庫，分別為DB-A，DB-B。假設持久層框架使用iBatis來實現，那麼SqlMapClient對象在創建時，對於兩個不同的DB連接要有兩個不同的SqlMapClient對象，假設我們有一個Service類為MyService.java，該類中有兩個SqlMapClient對象sqlMapA、sqlMapB分別對應著DB-A、DB-B。先看看我們的SqlMapClient.java類：（自定義SqlMapClient類，用來演示。） import java.util.Map; import org.apache.commons.lang.builder.ToStringBuilder; import org.apache.commons.lang.builder.ToStringStyle; @SuppressWarnings（"unchecked"） public class SqlMapClient { public SqlMapClient（String s, String t） { sqlMap = s; type = t; } public SqlMapClient（） { } private String type = null; private String sqlMap = null; // get、set方法略 // 用於演示查詢後返回一個String的返回結果 public String selectForObject（String sql, Map in） { return this.toString（）； } @Override public String toString（） { return new ToStringBuilder（this, ToStringStyle.SHORT_PREFIX_STYLE）。append（"sqlMap", sqlMap） .append（"type", type）。toString（）； } } MyService.java類實現： import java.util.Map; @SuppressWarnings（"unchecked"） public class MyService { @DataSource（type="B", sqlMap="com/annotation/sql-map-config-B.xml"） private SqlMapClient sqlMapB = null; @DataSource（type="A", sqlMap="com/annotation/sql-map-config-A.xml"） private SqlMapClient sqlMapA = null; // get、set方法略 // 模擬在DB-B資料庫取得數據 public String selectForObjectFromB（String sql, Map in） { return sqlMapB.selectForObject（"", null）； } // 模擬在DB-A資料庫取得數據 public String selectForObjectFromA（String sql, Map in） { return sqlMapA.selectForObject（"", null）； } } 接下來就是我們的註解類：DataSource.java import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target（ElementType.FIELD） @Retention（RetentionPolicy.RUNTIME） public @interface DataSource { /** * Dao的類型 * @return */ String type（） default "A"; // 連接的資料庫類型 A or B String sqlMap（） default ""; // Sql-Map-Config文件的路徑，用於載入iBatis的SqlMapClient對象 } 定義資源注入的介面 IFieldWiring.java。之所以這里要定義這個介面，是為了以後擴展用，我們很方便的定義更多的自定義註解。 IFieldWiring.java import java.lang.annotation.Annotation; import java.lang.reflect.Field; public interface IFieldWiring { Class clazz = obj.getClass（）； try { String methodname = "get" + StringUtils.capitalize（fieldName）； Method method = clazz.getDeclaredMethod（methodname）； method.setAccessible（true）； return method.invoke（obj）； } catch （Exception e） { try { Field field = clazz.getDeclaredField（fieldName）； field.setAccessible（true）； return field.get（obj）； } catch （Exception e1） { e1.printStackTrace（）； } } return null; } public static void setFieldValue（Object target, String fname, Class fieldClass, Object fieldObj） { if （！fieldClass.isAssignableFrom（fieldObj.getClass（））） { return; } Class clazz = target.getClass（）； try { Method method = clazz.getDeclaredMethod（"set" + Character.toUpperCase（fname.charAt（0）） + fname.substring（1）， fieldClass）； method.setAccessible（true）； method.invoke（target, fieldObj）； } catch （Exception e） { try { Field field = clazz.getDeclaredField（fname）； field.setAccessible（true）； field.set（target, fieldObj）； } catch （Exception e1） { e1.printStackTrace（）； } } } } 已經基本大功告成了，只要將我們的DataSourceWiring.java類使用起來即可。 MyAnnotationBeanProcessor.java，這個類主要用於為bean對象注入資源。 import java.lang.reflect.Field; public class MyAnnotationBeanProcessor { /** * 注入資源 * @param serviceObject * @param fieldAutoWirings // 所有實現IFieldWiring的介面的對象，我們可以在此擴展 * @throws Exception */ public void wire（Object serviceObject, IFieldWiring fieldAutoWirings） throws Exception { Class cls = serviceObject.getClass（）； for （Field field : cls.getDeclaredFields（）） { for （IFieldWiring fieldAutoWiring : fieldAutoWirings） { if （field.isAnnotationPresent（fieldAutoWiring.annotationClass（））） { fieldAutoWiring.wiring（serviceObject, field）； break; } } } } } 好了，開始我們的測試類：FieldWiringTest.java public class FieldWiringTest { public static void main（String args[]） throws Exception { MyAnnotationBeanProcessor processor = new MyAnnotationBeanProcessor（）； MyService b = new MyService（）； processor.wire（b, new DataSourceWiring（））； // 注入DataSource資源 System.out.println（b.selectForObjectFromB（"", null））； System.out.println（b.selectForObjectFromA（"", null））； } } 執行結果： SqlMapClient[sqlMap=com/annotation/sql-map-config-B.xml,type=B] SqlMapClient[sqlMap=com/annotation/sql-map-config-A.xml,type=A] 由執行結果可以說明DataSource資源已經被我們正確的注入了。如果想擴展的話，只需要新建一個類實現IFieldWiring介面即可。假設叫InParamWiring.java，實現了介面定義的兩個方法後，在使用的時候，只要用以下代碼便可將資源注入了： MyAnnotationBeanProcessor processor = new MyAnnotationBeanProcessor（）； MyService b = new MyService（）； processor.wire（b, new DataSourceWiring（）， new InParamWiring（））； // 注入DataSource、InParam資源. 更多Java學習技巧，盡在博洋教育。若您想了解java程序培訓價格，歡迎向我們的在線老師進行詳細了解。

『捌』如何在Spring中注入Java集合類

//普通javabean
publicclassNotificationBean{
publicMaphobby;

publicMapgetHobby(){
returnhobby;
}

publicvoidsetHobby(Maphobby){
this.hobby=hobby;
}
}

<!--配置文件application-spring.xml-->
<beanid="notificationBean"class="com.straw.spring.beans.NotificationBean">
<propertyname="hobby">
<map>
<entrykey="a"value="a"/>
<entrykey="b"value="b"/>
</map>
</property>
</bean>

//java測試類
publicclassMainTest{
publicstaticvoidmain(String[]args){
=("application-spring.xml");
=(NotificationBean)ap.getBean("notificationBean");
Maphobby=notificationBean.getHobby();
Set<String>set=hobby.keySet();
for(Strings:set){
System.out.println(s+":"+hobby.get(s));
}
}
}
//運行結果
a:a
b:b

『玖』如何通俗的理解java的依賴注入

假設你編寫了兩個類，一個是人(Person)，一個是手機(Mobile)。
人有時候需要用手機打電話，需要用到手機的callUp方法。
傳統的寫法是這樣:
Java code
public class Person{
public boolean makeCall(long number){
Mobile mobile=new Mobile();
return mobile.callUp(number);
}
}
也就是說，類Person的makeCall方法對Mobile類具有依賴，必須手動生成一個新的實例new Mobile()才可以進行之後的工作。
依賴注入的思想是這樣，當一個類(Person)對另一個類(Mobile)有依賴時，不再該類(Person)內部對依賴的類(Moblile)進行實例化，而是之前配置一個beans.xml,告訴容器所依賴的類(Mobile)，在實例化該類(Person)時，容器自動注入一個所依賴的類(Mobile)的實例。
介面：
Java code
public Interface MobileInterface{
public boolean callUp(long number);
}
Person類：
Java code
public class Person{
private MobileInterface mobileInterface;
public boolean makeCall(long number){
return this.mobileInterface.callUp(number);
}
public void setMobileInterface(MobileInterface mobileInterface){
this.mobileInterface=mobileInterface;
}
}
在xml文件中配置依賴關系
Java code
<bean id="person" class="Person">
<property name="mobileInterface">
<ref local="mobileInterface"/>
</property>
</bean>
<bean id="mobileInterface" class="Mobile"/>
這樣，Person類在實現撥打電話的時候，並不知道Mobile類的存在，它只知道調用一個介面MobileInterface，而MobileInterface的具體實現是通過Mobile類完成，並在使用時由容器自動注入，這樣大大降低了不同類間相互依賴的關系。
java依賴注入的方法：set注入，構造方法注入，介面注入。

『拾』 java類注入到另一個

方法如下：
如果另一個類是在寫的java文件夾下,就直接new一個對象,然後調用方法就好,如果不是在本文件夾下,就需要在代碼最前面添加該包,然後new對象,最後調用方法。

導航:首頁 > 編程語言 > java注入類

java注入類

與java注入類相關的資料