SPRING01_概述配置文件bean实例化依赖注入的方式依赖注入的数据类型分模块开发API使用

Posted 所得皆惊喜

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SPRING01_概述配置文件bean实例化依赖注入的方式依赖注入的数据类型分模块开发API使用相关的知识，希望对你有一定的参考价值。

文章目录

    控制反转(IOC):将控制权转给spring,容器,new对象的权利交给了spring(Inverse of control)
    依赖注入(DI):将对象的依赖自动注入到属性值(Dependency Injection)
    (比如UserImpl中注入UserDao)
    切面编程(AOP):Aspect Oriented programming,即面向切面编程。是通过预编译的方式和
    运行期动态代理来实现程序功能的统一维护的一种技术

①. Spring基本概念

  • ①. Spring是分层的Java SE/EE应用 full-stack 轻量级开源框架,以IoC(Inverse Of Control:反转控制)和 AOP(Aspect Oriented Programming:面向切面编程)为内核

  • ②. spring的简介:
    Rod Johnson ( Spring 之父),2017年,9月份发布了Spring的最新版本Spring5.0

  • ③. Spring的优势

  1. 方便解耦,简化开发(IOC:将创建对象交给spring来处理)
  2. AOP 编程的支持
  3. 声明式事务的支持
  4. 方便程序的测试
  • ④. Spring的快速入门
//导入Spring开发的基本包坐标
<properties>
	<spring.version>5.0.5.RELEASE</spring.version>
</properties>
<!--导入spring的context坐标,context依赖core、beans、expression-->
<dependencies> 
    <dependency>  
        <groupId>org.springframework</groupId> 
        <artifactId>spring-context</artifactId> 
        <version>${spring.version}</version>
    </dependency>
</dependencies>

//编写Dao接口和实现类
public interface UserDao {  
    public void save();
}

public class UserDaoImpl implements UserDao {  
        @Override  
        public void save() {
        	System.out.println("UserDao save method running....");
	}
}

//创建Spring核心配置文件
在类路径下(resources)创建applicationContext.xml配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"             		       
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
    http://www.springframework.org/schema/beans      	      
    http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

// 在Spring配置文件中配置UserDaoImpl
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"             		   
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
    http://www.springframework.org/schema/beans      	             
    http://www.springframework.org/schema/beans/spring-beans.xsd">
    
   <bean id="userDao" class="com.xiaozhi.dao.impl.UserDaoImpl"></bean>
</beans>

// 使用Spring的API获得Bean实例
@Test
public void test1(){
		ApplicationContext applicationContext = 
		new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");   				      
        userDao.save();
 }

②. spring的配置文件

  • ①. Bean标签基本配置
  1. 用于配置对象交由Spring来创建
  2. 默认情况下它调用的是类中的无参构造函数,如果没有无参构造函数则不能创建成功
  3. 基本属性
    id:Bean实例在Spring容器中的唯一标识
    class:Bean的全限定名称(类中必须要有无参构造)
  • ②. Bean标签范围配置
  1. Singleton:单列,默认。在配置文件加载进内存时创建对象,此对象伴随Spring容器的声明周期
  2. prototype:原型,每次都是不同的实例,在调用getBean方法时创建对象,会由垃圾回收器回收
  • ③. 关于生命周期 掌握

单例和多例说明
(1). 单例(原型) : singleton
Bean的实例化个数:1个
Bean的实例化时机:当Spring核心文件被加载时,实例化配置的Bean实例
Bean的生命周期:
对象创建:当应用加载,创建容器时,对象就被创建了
对象运行:只要容器在,对象一直活着
对象销毁:当应用卸载,销毁容器时,对象就被销毁了
(2). 多例的:prototype
Bean的实例化个数:多个
Bean的实例化时机:当调用getBean()方法时实例化Bean
对象创建:当使用对象时,创建新的对象实例
对象运行:只要对象在使用中,就一直活着
对象销毁:当对象长时间不用时,被 Java 的垃圾回收器回收了

  • ④. Bean生命周期配置(了解)
    init-method:指定类中的初始化方法名称
    destroy-method:指定类中销毁方法名称

③. bean的实例化的三种方式

  • ①. 无参构造方法实例化 掌握
	<bean id="userDao" class="com.xiaozhi.dao.impl.UserDaoImpl"/>
  • ②. 工厂静态方式实例化
	public class StaticFactoryBean {
	    public static UserDao createUserDao(){    
	    return new UserDaoImpl();
	    }
	}

	<bean id="userDao" class="com.xiaozhi.factory.StaticFactoryBean" 
    factory-method="createUserDao" />
  • ③. 工厂实例方式实例化
	public class DynamicFactoryBean {  
		public UserDao createUserDao(){        
			return new UserDaoImpl(); 
		}
	}

	<bean id="factoryBean" class="com.xiaozhi.factory.DynamicFactoryBean"/>
	<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>

④. 依赖注入的方式

  • ①. 依赖注入(Dependency Injection):它是Spring框架核心 IOC 的具体实现(将对象的依赖自动注入到属性值(Dependency Injection))

  • ②. 有参构造方法

	public class UserServiceImpl implements UserService {
	    private UserDao userDao;
	    public UserServiceImpl(UserDao userDao1) {
	        this.userDao = userDao1;
	    }
	    public void save() {
       	 userDao.save();
   		}
	}

	<bean id="userDao" class="com.xiaozhi.dao.impl.UserDaoImpl"/>
	<bean id="userService" class="com.xiaozhi.service.impl.UserServiceImpl">  
	<---这个name对应有参构造中的userDao参数-->    		   	
	<constructor-arg name="userDao1" ref="userDao"></constructor-arg>
	</bean>
  • ②. set方法
//1.在UserServiceImpl中添加setUserDao方法
public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
                this.userDao = userDao;
    }
    public void save() {
        userDao.save();
    }
}
//2.配置Spring容器调用set方法进行注入
<bean id="userDao" class="com.xiaozhi.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.xiaozhi.service.impl.UserServiceImpl">
	<!--这个name要求是set后首字母改小写-->
	<property name="userDao" ref="userDao"/>
</bean>

	//当我们执行这些代码的时候,会加载配置文件,配置文件中会依次向下执行
	//先创建UserDaoImpl的对象,后创建UserServiceImol对象
	//最后调用UserServiceImpl中的set方法
	ClassPathXmlApplicationContext app = 
	new ClassPathXmlApplicationContext("applicationContext.xml");
	UserDao userDao1 = (UserDao) app.getBean("userDao");
	System.out.println(userDao1);
  • ③. set方法:P命名空间注入 了解
  1. ​P命名空间注入本质也是set方法注入,但比起上述的set方法注入更加方便,主要体现在配置文件中,如下:
xmlns:p="http://www.springframework.org/schema/p"
  1. 其次,需要修改注入方式
<bean id="userService" class="com.xiaozhi.service.impl.UserServiceImpl" p:userDao-
 ref="userDao"/>

⑤. Bean的依赖注入的数据类型

  • ①. 普通数据类型(value) ②. 引用数据类型(ref) ③. 集合数据类型

  • ②. 基本数据类型

	public class UserDaoImpl implements UserDao {
	private String company;
	    private int age;
	    public void setCompany(String company) {
	        this.company = company;
	    }
	    public void setAge(int age) {
	        this.age = age;
	    }
	    public void save() {
	        System.out.println(company+"==="+age);
	        System.out.println("UserDao save method running....");   
	    }
	}


	<bean id="userDao" class="com.xiaozhi.dao.impl.UserDaoImpl">
	    <property name="company" value="TANGZHI"></property>
	    <property name="age" value="15"></property>
	</bean>

  • ③. 引用数据类型(UserService中注入了UserDao)

  • ④. 集合类型的注入

	//(1).集合数据类型(List<String>)的注入
	public class UserDaoImpl implements UserDao {
		private List<String> strList;
		public void setStrList(List<String> strList) {
			this.strList = strList;
		}
		public void save() {
	        System.out.println(strList);
	        System.out.println("UserDao save method running....");
		}
	}
	<bean id="userDao" class="com.xiaozhi.dao.impl.UserDaoImpl">
	    <property name="strList">
	        <list>
	            <value>aaa</value>
	            <value>bbb</value>
	            <value>ccc</value>
	        </list>
	    </property>
	</bean>

	//(2). 集合数据类型(List<User>)的注入
	public class UserDaoImpl implements UserDao {
		private List<User> userList;
		public void setUserList(List<User> userList) {
		this.userList = userList;  
	 }
	public void save() {
		System.out.println(userList);
		System.out.println("UserDao save method running....");
		}
	}
	<bean id="u1" class="com.xiaozhi.domain.User"/>
	<bean id="u2" class="com.xiaozhi.domain.User"/>
	<bean id="userDao" class="com.xiaozhi.dao.impl.UserDaoImpl">
	    <property name="userList">
	        <list>
	            <bean class="com.xiaozhi.domain.User"/>
	            <bean class="com.xiaozhi.domain.User"/>
	            <ref bean="u1"/>
	            <ref bean="u2"/>       
	        </list>
	    </property>
	</bean>

	//(3). 集合数据类型( Map<String,User> )的注入
	public class UserDaoImpl implements UserDao {
	    private Map<String,User> userMap;
	    public void setUserMap(Map<String, User> userMap) {
	    this.userMap = userMap;
	    }    
	public void save() {      
		System.out.println(userMap);
		System.out.println("UserDao save method running....");
		}
	}
	<bean id="u1" class="com.xiaozhi.domain.User"/>
	<bean id="u2" class="com.xiaozhi.domain.User"/>
	<bean id="userDao" class="com.xiaozhi.dao.impl.UserDaoImpl">
	    <property name="userMap">
	        <map>            
	            <entry key="user1" value-ref="u1"/>
	            <entry key="user2" value-ref="u2"/>
	        </map>
	    </property>
	</bean>

	//(4). 集合数据类型(Properties)的注入
	public class UserDaoImpl implements UserDao {
	    private Properties properties;
	    public void setProperties(Properties properties) {
	        this.properties = properties;
	    }
		public void save() {
			System.out.println(properties);
			System.out.println("UserDao save method running....");
		}
	}
	<bean id="userDao" class="com.xiaozhi.dao.impl.UserDaoImpl">
	    <property name="properties">
	        <props>
	            <prop key="p1">aaa</prop>
	            <prop key="p2">bbb</prop> 
	            <prop key="p3">ccc</prop>
	        </props>
	    </property>
	</bean>

⑥. 引入其他配置文件(分模块开发)

  • ①. 实际开发中,Spring的配置内容非常多,这就导致Spring配置很繁杂且体积很大,所以,可以将部分配置拆解到其他配置文件中,而在Spring主配置文件通过import标签进行加载

  • ②. <import resource="applicationContext-xxx.xml"/>

⑦. API的使用

  • ①. ApplicationContext的实现类
  1. ClassPathXmlApplicationContext :它是从类的根路径下加载配置文件 推荐使用这种
  2. FileSystemXmlApplicationContext : 它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置
  3. AnnotationConfigApplicationContext:当使用注解配置容器对象时,需要使用此类来创建 spring 容器。它用来读取注解
  • ②. getBean()方法使用

详解:
(1).其中,当参数的数据类型是字符串时,表示根据Bean的id从容器中获得Bean实例,返回是Object,需要强转。
(2).当参数的数据类型是Class类型时,表示根据类型从容器中匹配Bean实例,当容器中相同类型的Bean有多个时,则此方法会报错
getBean()方法使用:

以上是关于SPRING01_概述配置文件bean实例化依赖注入的方式依赖注入的数据类型分模块开发API使用的主要内容，如果未能解决你的问题，请参考以下文章

Spring学习IOC容器配置bean：定义与实例化

面经三

Spring -- Spring配置文件详解（Bean的依赖注入的数据类型（基本类型引用类型集合类型））

IOC容器

看看Spring的源码——bean实例化

关于Spring依赖注入的问题