Spring XML 注入_xml定义userserviceimpl对象-CSDN博客

本文链接：https://blog.csdn.net/yu342107056/article/details/85716290

Spring XML 注入

DI:
- 依赖注入：
- - 注入数据的方式：

DI:

依赖注入：

从Spring 容器中取出对象，注入到需要的地方。

根据所需要了解的注入方式创建下方的类。

创建UserServiceImpl类

package com.arno.service.impl;

import com.arno.dao.UserDao;
import com.arno.entity.User;
import com.arno.service.UserService;

public class UserServiceImpl implements UserService {
	private UserDao userDao;
	public void setUserDao(UserDao userDao){
		this.userDao=userDao;
	}
	@Override
	public boolean addUser(User user) {
		System.out.println("UserSerivceImpl.addUser()");
		userDao.addUser(user);
		return false;
	}

	@Override
	public boolean updateUser(User user) {
		System.out.println("UserSerivceImpl.updateUser()");
		userDao.updateUser(user);
		return false;
	}

}

创建UserDaoImpl类

package com.arno.dao.impl;

import com.arno.dao.UserDao;
import com.arno.entity.User;

public class UserDaoImpl implements UserDao {
	private String driverClass;
	private int port;
	private String dbUserName;
	private String dbPassword;
	
	public void setDriverClass(String driverClass) {
		this.driverClass = driverClass;
	}

	public void setPort(int port) {
		this.port = port;
	}

	public void setDbUserName(String dbUserName) {
		this.dbUserName = dbUserName;
	}

	public void setDbPassword(String dbPassword) {
		this.dbPassword = dbPassword;
	}

	@Override
	public int addUser(User user) {
		System.out.println("UserDaoImpl.adduser()");
		System.out.println(driverClass+"   "+port+"   "+dbUserName+"   "+dbPassword);
		return 0;
	}

	@Override
	public int updateUser(User user) {
		System.out.println("UserDaoImpl.updateuser()");
		return 0;
	}

}

创建Message类

package com.arno.collection;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Message {
	private List list;
	private Set set;
	private Map map;
	private Properties props;
	public List getList() {
		return list;
	}
	public void setList(List list) {
		this.list = list;
	}
	public Set getSet() {
		return set;
	}
	public void setSet(Set set) {
		this.set = set;
	}
	public Map getMap() {
		return map;
	}
	public void setMap(Map map) {
		this.map = map;
	}
	public Properties getProps() {
		return props;
	}
	public void setProps(Properties props) {
		this.props = props;
	}
	@Override
	public String toString() {
		return "Message [list=" + list + ", set=" + set + ", map=" + map + ", props=" + props + "]";
	}
	
	
}

注入数据的方式：

setter方式注入：

1.单值注入

在xml中创建UserDaoImpl 对象，并且注入4个属性值

<!-- 告知spring创建 UserDaoImpl对象        对象名:userDao
        此对象中注入4个数据
        property节点对应一个set方法
        name="driverClass"  driverClass->DriverClass->setDriverClass
        setDriverClass字符串去UserDaoImpl类中匹配setDriverClass的方法
        value="com.mysql.jdbc.Driver"
     -->
    <bean id="userDao"  class="com.arno.dao.impl.UserDaoImpl">
       <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
       <property name="port" value="3306"></property>
       <property name="dbUserName" value="root"></property>
       <property name="dbPassword" value="root"></property>

    </bean>

2.对象注入

在xml中创建UserDaoImpl 对象，注入4个属性值，对象命名为userDao，注入下方名为userService的对象中

		<!-- 告知spring创建 UserDaoImpl对象        对象名:userDao
		     -->
		    <bean id="userDao"  class="com.arno.dao.impl.UserDaoImpl">
		       <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		       <property name="port" value="3306"></property>
		       <property name="dbUserName" value="root"></property>
		       <property name="dbPassword" value="root"></property>
		    </bean>
		    <!-- 告知spring创建 UserServiceImpl对象  对象名:userService
		    	userService对象中需要UserDaoImpl类的对象
		    	或
		    	userService对象中需要UserDao接口的对象
		    	proerty属性节点,每一个property节点都会对应一个setter方法
		    	name="userDao" userDao->UserDao->setUserDao
		    	拿setUserDao这个字符串作为方法的名称去UserServiceImpl类中寻找是否有setUserDao的方法
		                     如果有就反射调用setUserDao方法,方法的参数就是ref="userDao"
		        ref="userDao"  ref:reference引用    userDao 是spring容器中的一个对象名称
		      -->
		    <bean id="userService" class="com.arno.service.impl.UserServiceImpl">
		    	<property name="userDao" ref="userDao"></property>
		    </bean>

3.集合注入（直接注入和间接注入）

直接注入,创建Message对象，通过标签直接注入属性值

	<!-- 直接集合注入 -->
	<bean id="message1" class="com.arno.collection.Message">
		<property name="list">
			<list>
				<value>北京</value>
				<value>上海</value>
				<value>广州</value>
				<ref bean="hello"></ref>
			</list>
		</property>
		<property name="set">
			<set>
				<value>北京</value>
				<value>上海</value>
				<value>广州</value>
				<ref bean="hello"></ref>
			</set>
		</property>
		<property name="map">
			<map>
			    <entry key="bj" value="北京"></entry>
				<entry key="sh" value="上海"></entry>
				<entry key="gz" value="广州"></entry>
			</map>
		</property>
		<property name="props">
			<props>
				<prop key="bj">北京</prop>
				<prop key="sh">上海</prop>
				<prop key="gz">广州</prop>
			</props>
		</property>
	</bean>

间接注入,创建Hello对象和集合。创建Message对象，通过标签引用hello对象和集合注入到Message对象的属性中

	<!-- 间接集合注入 -->
	<bean id="hello" class="com.arno.ioc.Hello"></bean>
	<util:list id="ulist">
		<value>北京</value>
		<value>上海</value>
		<value>广州</value>
		<ref bean="hello"></ref>
	</util:list>
	<util:set id="uset">
		<value>北京</value>
		<value>上海</value>
		<value>广州</value>
		<ref bean="hello"></ref>
	</util:set>
	<util:map id="umap">
	  	<entry key="bj" value="北京"></entry>
		<entry key="sh" value="上海"></entry>
		<entry key="gz" value="广州"></entry>
		<entry key="hello" value-ref="hello"></entry>
	</util:map>
	<util:properties id="uprops">
		<prop key="bj">北京</prop>
		<prop key="sh">上海</prop>
		<prop key="gz">广州</prop>
	</util:properties>
	<bean id="message2" class="com.arno.collection.Message">
		<property name="list" ref="ulist"></property>
		<property name="set" ref="uset"></property>
		<property name="map" ref="umap"></property>
		<property name="props" ref="uprops"></property>
	</bean>

4.属性注入（把属性文件中的数据注入给对象中）

${}方式：
创建mysql.properties文件(注意规避关键词)

	jdbc_driverClass=com.mysql.jdbc.Driver
	jdbc_url=jdbc:mysql://localhost:3306/tesdb
	jdbc_userName=root
	jdbc_userPassword=root

创建jdbcUtil1和jdbcUtil2类

public class JDBCUtil1 {
		private String driverClass;
		private String url;
		private String userName;
		private String userPassword;
	        getter and setter(生成get/set方法)
	}

通过${}方式取得mysql.properties内容并注入到jdbcUtil1对象中

	<!-- 用spring把属性文件的内容加载到spring容器中 ,多个属性文件用逗号间隔-->
	  	<context:property-placeholder location="classpath:conf/mysql.properties"/>
	  	
	  	
	  	<bean id="jdbcUtil1" class="com.arno.properties.JDBCUtil1">
	  		<property name="driverClass" value="${jdbc_driverClass}"></property>
	  		<property name="url" value="${jdbc_url}"></property>
	  		<property name="userName" value="${jdbc_userName}"></property>
	  		<property name="userPassword" value="${jdbc_userPassword}"></property>
	  	</bean>

#{}方式：
通过#{}方式取得mysql.properties内容并注入到jdbcUtil1对象中

	<!-- 用spring把属性文件的内容加载到spring容器中 ,多个属性文件用逗号间隔-->
	  	<util:properties id="manyProperties"
	  	                 location="classpath:conf/mysql.properties"></util:properties>
	  	  	
	  	
	  	<bean id="jdbcUtil2" class="com.arno.properties.JDBCUtil2">
	  		<property name="driverClass" value="#{manyProperties.jdbc_driverClass}"></property>
	  		<property name="url" value="#{manyProperties.jdbc_url}"></property>
	  		<property name="userName" value="#{manyProperties.jdbc_userName}"></property>
	  		<property name="userPassword" value="#{manyProperties.jdbc_userPassword}"></property>
	  	</bean>

5.空值注入

空值两种："" 空字符串和null 空指针

创建Kong类

package com.arno.kong;

public class Kong {
	private String str1;
	private String str2;
	public String getStr1() {
		return str1;
	}
	public void setStr1(String str1) {
		this.str1 = str1;
	}
	public String getStr2() {
		return str2;
	}
	public void setStr2(String str2) {
		this.str2 = str2;
	}
	
}

创建Kong对象，注入“”和null

     <!--str1存储的是空字符串 ,str2存储的null-->
      <bean id="kong" class="com.arno.kong.Kong">
		<property name="str1" value=""></property>
		<property name="str2">
			<null />
		</property>
	</bean>

上面的五种方式用setter方式把数据注入到需要的对象中

构造方式注入：

用构造方法注入数据:
创建Hello对象和ConstructorClass对象，并通过ConstructorClass构造方法注入Hello对象和属性值

        <bean id="hello" class="com.arno.ioc.Hello"></bean>
	<bean id="constructorClass" class="com.arno.constructor.ConstructorClass">
		<constructor-arg index="0" value="张三"></constructor-arg>
		<constructor-arg index="1" value="20"></constructor-arg>
		<constructor-arg index="2" ref="hello"></constructor-arg>
		
	</bean>

创建ConstructorClass类，并创建构造方法

ConstructorClass.java
	public class ConstructorClass {
		private String name;
		private String  age;
		private Hello hello;
		
		public ConstructorClass(String name, String age, Hello hello) {
			this.name = name;
			this.age = age;
			this.hello = hello;
		}
		public String getName() {
			return name;
		}
		public String getAge() {
			return age;
		}
		public Hello getHello() {
			return hello;
		}
		
	}

总结:在开发中用setter方法是最多,也最常用,灵活也最好

在开发中构造注入不常用,构造注入数据一般用在框架中居多

autowire 自动装配

byType 根据类型注入，
创建User对象，根据User对象中需要注入的属性，在spring容器中寻找是否有对应类型的对象,如果有就注入
前提:在spring容器中对应的类类型不能两个及以上

	<bean id="user" 
	      class="com.arno.autowire.User"
	      autowire="byType">
	</bean>

byName根据名字注入，例如User中有Dog类需要注入，并且User类中有setDog()方法，根据setDog方法名，去掉set并首字母小写得到名字dog，在spring容器中寻找是否有对应名字的对象，然后通过set方法进行注入。

<!-- 
       autowire="byName"  按照名称自动装配
                  过程:首先搜索User类,类种需要两个对象,分别是Cat类和Dog类
                            且类中有setCat方法,setCat->Cat->cat,拿cat去spring容器中寻找是否有此对象
     -->
    <bean id="user" 
	      class="com.arno.autowire.User"
	      autowire="byName">
	</bean>