spring全家桶之spring入门

####spring

spring是什么

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核

控制反转(Inversion of Control)

1. 概念:
IoC也称为依赖注入（DI）。这是一个过程，通过这个过程，对象定义它们的依赖关系，即它们使用的其他对象，只能通过构造函数参数，工厂方法的参数，或者在构造或从工厂方法返回后在对象实例上设置的属性。 。然后容器 在创建bean时注入这些依赖项。这个过程基本上是相反的，因此称为控制反转（IoC），bean本身通过使用类的直接构造或诸如服务定位器模式之类的机制来控制其依赖关系的实例化或位置。

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。
2. 作用:
	 削减计算机程序的耦合(解除我们代码中的依赖关系)。

spring IOC容器 和bean简介

在Spring中，构成应用程序主干并由Spring IoC 容器管理的对象称为bean。bean是一个由Spring IoC容器实例化，组装和管理的对象。否则，bean只是应用程序中众多对象之一。Bean及其之间的依赖 关系反映在容器使用的配置元数据中。

该接口org.springframework.context.ApplicationContext代表Spring IoC容器，负责实例化，配置和组装上述bean。容器通过读取配置元数据获取有关要实例化，配置和组装的对象的指令。配置元数据以XML，Java注释或Java代码表示。它允许您表达组成应用程序的对象以及这些对象之间丰富的相互依赖性。

BeanFactory 和 ApplicationContext 的区别

**BeanFactory 才是 Spring 容器中的顶层接口。ApplicationContext 是它的子接口。**
	BeanFactory 和 ApplicationContext 的区别：
	创建对象的时间点不一样。
		ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
		BeanFactory：什么使用什么时候创建对象。

#####ApplicationContext接口的实现类
ClassPathXmlApplicationContext ：
它是从类的根路径下加载配置文件 推荐使用这种
FileSystemXmlApplicationContext ：
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext:
当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

spring基于xml配置

Spring配置由容器必须管理的至少一个且通常不止一个bean定义组成。基于XML的配置元数据显示这些bean配置为<bean/>顶级元素内的<beans/>元素。bean定义对应于构成应用程序的实际对象
1. bean标签:
	1. 作用：
		用于配置对象让 spring 来创建的。
		默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
	2. 属性:
		id：给对象在容器中提供一个唯一标识。用于获取对象。
		class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
	scope：指定对象的作用范围。
		* singleton :默认值，单例的.
		* prototype :多例的.
		* request  :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
		* session  :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
		* global session  :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么
	globalSession 相当于 session.
	init-method：指定类中的初始化方法名称。
	destroy-method：指定类中销毁方法名称。
2. 基于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>
3. 
	<!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中
		id 属性：对象的唯一标识。(用于之后从spring容器获得实例时使用的)
		class 属性：指定要创建对象的全限定类名
	-->
	<!-- 配置 service -->
		<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
	<!-- 配置 dao -->
	<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
4. 实例化Spring IoC容器
	1. 提供给ApplicationContext构造函数的位置路径实际上是资源字符串，允许容器从各种外部资源（如本地文件系统，Java等）加载配置元数据CLASSPATH
		// 使用 ApplicationContext 接口，就是在获取 spring 容器
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationcontext.xml"); 
		// 根据 bean 的 id 获取对象(两种方式)
			AccountService accountService = applicationContext.getBean("accountService", AccountService.class);
    		AccountDao accountDao = (AccountDao) applicationContext.getBean("accountDao");

实例化bean的三种方式

1. 使用构造函数实例化
	第一种方式：使用默认无参构造函数
	<!--在默认情况下：它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。-->
	<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"/> 

2. 使用静态工厂方法实例化
	1. 模拟静态工厂,创建业务层实现类
		public class StaticFactory { 
			public static IAccountService createAccountService(){
				return new AccountServiceImpl();
			}
		} 
	 <!-- 此种方式是:使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
		id 属性：指定 bean 的 id，用于从容器中获取
		class 属性：指定静态工厂的全限定类名
		factory-method 属性：指定生产对象的静态方法(指定工厂方法本身的名称)
		-->
		<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="createAccountService"></bean>

3. 使用实例工厂方法实例化
	1. 模拟实例工厂
		public class InstanceFactory {
			public IAccountService createAccountService(){
				return new AccountServiceImpl();
			}
		} 
	<!-- 此种方式是：
	先把工厂的创建交给 spring 来管理。然后在使用工厂的 bean 来调用里面的方法
	factory-bean 属性：用于指定实例工厂 bean 的 id。
	factory-method 属性：用于指定实例工厂中创建对象的方法。
	-->
	<!--使用普通工厂中的方法创建对象
		相当于 accountService = new InstanceFactory().getAccountService
		-->
	<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>
//该class属性保留为空，并在factory-bean属性中指定当前（或父/祖先）容器中bean的名称，该容器包含要调用以创建对象的实例方法。使用factory-method属性设置工厂方法本身的名称。
	<bean id="accountService" factory-bean="instancFactory" factory-method="createAccountService"></bean>

#####依赖注入
依赖注入（DI）是一个过程，通过这个过程，对象定义它们的依赖关系，即它们使用的其他对象，只能通过构造函数参数，工厂方法的参数或在构造或返回对象实例后在对象实例上设置的属性。从工厂方法。然后容器在创建bean时注入这些依赖项。这个过程基本上是反向的，因此名称Inversion of Control（IoC），bean本身通过使用类的直接构造或服务定位器模式来控制其依赖项的实例化或位置。

DI存在两个主要变体，基于构造函数的依赖注入和基于Setter的依赖注入。
1. 构造参数注入:
	1. 就是使用类中的构造函数，给成员变量赋值
	要求: 类中需要提供一个对应参数列表的构造函数。
	注意:注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入

	public class AccountServiceImpl implements IAccountService {
		private String name;
		private Integer age;
		private Date birthday;

		public AccountServiceImpl(String name, Integer age, Date birthday) {
			this.name = name;
			this.age = age;
			this.birthday = birthday;

		}
	}
	2. 涉及的标签:
		constructor-arg
			属性：
				index:指定参数在构造函数参数列表的索引位置
				type:指定参数在构造函数中的数据类型
				name:指定参数在构造函数中的名称 用这个找给谁赋值
			=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
				value:它能赋的值是基本数据类型和 String 类型
				ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean 
		例
			<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
			<constructor-arg name="name" value=" 张三 "></constructor-arg>
			<constructor-arg name="age" value="18"></constructor-arg>
			<constructor-arg name="birthday" ref="now"></constructor-arg>
			</bean>
			<bean id="now" class="java.util.Date"></bean>

2. set方法注入:
	1. 就是在类中提供需要注入成员的 set 方法
		<!-- 通过配置文件给 bean 中的属性传值：使用 set 方法的方式
			涉及的标签：
				property 
				属性：
					name：找的是类中 set 方法后面的部分
					ref：给属性赋值是其他 bean 类型的
					value：给属性赋值是基本数据类型和 string 类型的
					实际开发中，此种方式用的较多。
					-->
	2. 例:
		<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
		<property name="name" value="test"></property>
		<property name="age" value="21"></property>
		<property name="birthday" ref="now"></property>
		</bean>
		<bean id="now" class="java.util.Date"></bean> 

基于注解的IOC配置

**注解使用前提，添加命名空间，让spring扫描含有注解类 **
注解配置和 xml 配置要实现的功能都是一样的，都是要降低程序间的耦合。只是配置的形式不一样

1. 基于注解整合时，导入约束时需要多导入一个 context 名称空间下的约束。
			<?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:context="http://www.springframework.org/schema/context"
			    xsi:schemaLocation="http://www.springframework.org/schema/beans
			        http://www.springframework.org/schema/beans/spring-beans.xsd
			        http://www.springframework.org/schema/context
			        http://www.springframework.org/schema/context/spring-context.xsd">
			<!-- 告知 spring 创建容器时要扫描的包 -->
	    	<context:component-scan base-package="com.itheima"></context:component-scan>
	
			</beans> 

#####IOC常用注解(半注解 半xml)
1. 用于创建对象的
相当于：

	1.@Component取代<bean class=""> 
	@Component("id") 取代 <bean id="" class=""> 
	2.web开发，提供3个@Component注解衍生注解（功能一样）取代 
	@Repository ：dao层 
	@Service：service层 
	@Controller：web层 
2. 用于注入数据的
	 相当于:
	<property name="" ref="">
	<property name="" value="">

	普通值：@Value(" ")
	引用值： 
	方式1：按照【类型】注入 
	@Autowired 
	方式2：按照【名称】注入1 
	@Autowired 
	@Qualifier("名称") 
	方式3：按照【名称】注入2 
	@Resource("名称") 
3. 和生命周期相关的
	相当于：<bean id="" class="" init-method="" destroy-method="" />
	初始化：@PostConstruct 
	销毁：@PreDestroy 
4. 用于改变作用范围的
	相当于：<bean id="" class="" scope=""> 
	@Scope("prototype") 多例 
	取值：singleton prototype request session globalsession

#####纯注解开发配置
需要提供一个spring配置类(把配置文件用类来代替)加上相关注解
1. @Configuration :用于指定当前类是一个 spring 配置类
2. @ComponentScan :用于指定 spring 在初始化容器时要扫描的包(配置创建容器时要扫描的包)
3. @Bean :该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器。(获取数据源和 JdbcTemplate 对象)
4. @PropertySource : 用于加载.properties 文件中的配置 例如配置数据源时，可以把连接数据库的信息写到properties 配置文件中，就可以使用此注解指定 properties 配置文件的位置。
5. @Import :用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration 注解。
6. ApplicationContext ac =new AnnotationConfigApplicationContext(SpringConfiguration.class);

#####spring整合junit
首先要导入spring-test的依赖，junit的jar包版本要是4.12以上
在测试类上添加一下注解：
@RunWith(SpringJUnit4ClassRunner.class)
使用spring提供的测试运行类替代原有的junit的测试运行类完成测试用例的执行。
spring提供的运行类在运行时会帮助我们先创建容器，所以才能在测试类中直接使用自动注入完成对象的获取
@ContextConfiguration(classes = SpringConfiguration.class)
在spring提供的测试运行类创建容器时，势必要加载配置。可以是xml的配置，也可以是配置类（用于纯注解开发）
此配置通过ContextConfiguration注解提供配置文件或配置类的位置。
classes：纯注解开发时提供配置类的位置
locations：xml作为配置文件时的位置。一般使用classpath:开头指定在类路径下查找文件。