java注入

① spring注入

哥们，忍不住 说你两句，你表达的比较乱，我没看出来 这有三个问题。依我含糊的理解，我的回答是：

对于 调用有参数的构造函数在

1) bean.xml中的例如这样配置
<bean id="str" class="java.lang.String">
<constructor-arg index="0">
<value>This is a String value</value>
</constructor-arg>
</bean>
这就相当于 new String("This is a String value");

2) 在源码类中用@Autowired注解，例如
public class Aaa{
private String str;

@Autowired
public Aaa(String str){
this.str=str;
}

//@Autowired
public Aaa(String str, String name){
this.str=str;
}

}
@Autowired 放在哪个构造函数上， 实例化时 就调用哪个！

② Spring是如何实现注入的

在使用Spring的IOC功能的时候，Spring提供了集中注入方式：属性注入，构造函数注入和工厂方法注入，更多的时候是使用的属性注入，即set方法注入。使用set方法注入要求在写bean的配置文件的时候，需要我们手动设置properties。诸如：
[java] view plain
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="testBean" class="com.jack.TestBean" scope="prototype"/>
<bean id="testAction" class="com.jack.TestAction" scope="prototype">
<property name="testBean" ref="testBean"/>
</bean>
</beans>

③ 什么是 注入类、宿主类（java）

注入类是被引用的类，宿主类应该是引用注入类的类。一般用XML文件或Annotation调用，ejb3.0是使用这个比较多的框架，用这个就不用传统的jndi了，其实原理是一样的，只是现在的架构给封装好了。好像是叫IOC模式，比较好用，可以省些代码，不过引用的注入类必须是受容器管制类。

④ 如何利用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程序培训价格，欢迎向我们的在线老师进行详细了解。

⑤ 如何通俗的理解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 求spring用@Autowired进行方法参数注入例子。

publicclassTestController{

privatefinalTestService1test1;
privatefinalTestService2test2;
privatefinalTestService3test3;

@Autowired
publicTestController(TestService1test1,TestService2test2,TestService3test3){
this.test1=test1;
this.test2=test2;
this.test3=test3;
}
}

这是构造方法的使用方式

⑦ “spring中注入是什么意思” 这里怎么理解“注入”的意思

spring通过“控制反转”实现了“依赖注入”。所谓的注入，我的理解是程序实现就像盖房子

spring允许你在类（class）里搭个框架，在配置文件中注明在什么地方用什么材料

在运行时spring按照你的配置真正向这个架子里“注入”了水泥、钢筋等等。

⑧ 什么是反向注入 java

反向注入就是通过框架自动的给你的类中的一些属性赋值啊。一般都是Spring框架

1、比如Action、Service、Dao中，假设你用了Spring框架，可以让框架给你这些类中的属性自动注入值，就是初始化那个属性。
2、Spring就相当于一个大的容器，里面啥都有，你要给一个属性复制，去它里面拿就是，但是要在Spring配置文件里先配置哦。

⑨ spring注解方式在一个普通的java类里面注入

不知道你说的“普通的java类”是什么。
在spring里要注入的话，相应的类都要纳入spring的管理，对象由spring创建，对象从spring获取。就像你上面的BaseDaoImpl和BaseServiceImpl。
如果UserCarManager也是由spring管理的话，那同样适用@autowired就可以注入。
看你的提问，应该是指没有纳入spring管理的类如何注入spring管理的对象，这种情况可以用srping相关的静态方法达到目的。
比如：
WebApplicationContext webAppContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
BaseDaoImpl baseDao = (BaseDaoImpl) BeanFactoryUtils.beanOfTypeIncludingAncestors(webAppContext, BaseDaoImpl.class);

⑩ java在抽象类中注入属性架构设计

首先纠正你一个错误。
抽象内是可以有它自己的属性的。
所以你完全可以将一些共通的属性写在抽象内里面。