Spring入门介绍
Spring诞生：

创建Spring的目的就是用来替代更加重量级的的企业级Java技术
简化Java的开发

基于POJO轻量级和最小侵入式开发
通过依赖注入和面向接口实现松耦合
基于切面和惯例进行声明式编程
通过切面和模板减少样板式代码
侵入式概念
Spring是一种非侵入式的框架...

侵入式

对于EJB、Struts2等一些传统的框架，通常是要实现特定的接口，继承特定的类才能增强功能

改变了java类的结构
非侵入式

对于Hibernate、Spring等框架，对现有的类结构没有影响，就能够增强JavaBean的功能
松耦合
前面我们在写程序的时候，都是面向接口编程，通过DaoFactroy等方法来实现松耦合

private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);

private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);

private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);

private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);

这里写图片描述

DAO层和Service层通过DaoFactory来实现松耦合

如果Serivce层直接new DaoBook()，那么DAO和Service就紧耦合了【Service层依赖紧紧依赖于Dao】。
而Spring给我们更加合适的方法来实现松耦合，并且更加灵活、功能更加强大！---->IOC控制反转

切面编程
切面编程也就是AOP编程，其实我们在之前也接触过...动态代理就是一种切面编程了...

当时我们使用动态代理+注解的方式给Service层的方法添加权限.

@Override
@permission("添加分类")
/*添加分类*/
public void addCategory(Category category) {
categoryDao.addCategory(category);
}

/*查找分类*/
@Override
public void findCategory(String id) {
categoryDao.findCategory(id);
}

@Override
@permission("查找分类")
/*查看分类*/
public List<Category> getAllCategory() {
return categoryDao.getAllCategory();
}

/*添加图书*/
@Override
public void addBook(Book book) {
bookDao.addBook(book);

}
Controller调用Service的时候，Service返回的是一个代理对象
代理对象得到Controller想要调用的方法，通过反射来看看该方法上有没有注解
如果有注解的话，那么就判断该用户是否有权限来调用 此方法，如果没有权限，就抛出异常给Controller，Controller接收到异常，就可以提示用户没有权限了。
AOP编程可以简单理解成：在执行某些代码前，执行另外的代码

Struts2的拦截器也是面向切面编程【在执行Action业务方法之前执行拦截器】
Spring也为我们提供更好地方式来实现面向切面编程！

引出Spring
我们试着回顾一下没学Spring的时候，是怎么开发Web项目的

1. 实体类--->class User{ }
2. daoclass--> UserDao{ .. 访问db}
3. service--->class UserService{ UserDao userDao = new UserDao();}
4. actionclass UserAction{UserService userService = new UserService();}
用户访问：

Tomcat->action->service->dao
我们来思考几个问题：

①：对象创建创建能否写死？
②：对象创建细节

对象数量

action 多个 【维护成员变量】
service 一个 【不需要维护公共变量】
dao 一个 【不需要维护公共变量】
创建时间

action 访问时候创建
service 启动时候创建
dao 启动时候创建
③：对象的依赖关系

action 依赖 service
service依赖 dao
对于第一个问题和第三个问题，我们可以通过DaoFactory解决掉(虽然不是比较好的解决方法)

对于第二个问题，我们要控制对象的数量和创建时间就有点麻烦了....

而Spring框架通过IOC就很好地可以解决上面的问题....

IOC控制反转
Spring的核心思想之一：Inversion of Control , 控制反转 IOC

那么控制反转是什么意思呢？？？对象的创建交给外部容器完成，这个就做控制反转。

Spring使用控制反转来实现对象不用在程序中写死
控制反转解决对象处理问题【把对象交给别人创建】
那么对象的对象之间的依赖关系Spring是怎么做的呢？？依赖注入，dependency injection.

Spring使用依赖注入来实现对象之间的依赖关系
在创建完对象之后，对象的关系处理就是依赖注入
上面已经说了，控制反转是通过外部容器完成的，而Spring又为我们提供了这么一个容器，我们一般将这个容器叫做：IOC容器.

无论是创建对象、处理对象之间的依赖关系、对象创建的时间还是对象的数量，我们都是在Spring为我们提供的IOC容器上配置对象的信息就好了。

那么使用IOC控制反转这一思想有什么作用呢？？？我们来看看一些优秀的回答...

来自知乎：https://www.zhihu.com/question/23277575/answer/24259844

我摘取一下核心的部分：

ioc的思想最核心的地方在于，资源不由使用资源的双方管理，而由不使用资源的第三方管理，这可以带来很多好处。第一，资源集中管理，实现资源的可配置和易管理。第二，降低了使用资源双方的依赖程度，也就是我们说的耦合度。
也就是说，甲方要达成某种目的不需要直接依赖乙方，它只需要达到的目的告诉第三方机构就可以了，比如甲方需要一双袜子，而乙方它卖一双袜子，它要把袜子卖出去，并不需要自己去直接找到一个卖家来完成袜子的卖出。它也只需要找第三方，告诉别人我要卖一双袜子。这下好了，甲乙双方进行交易活动，都不需要自己直接去找卖家，相当于程序内部开放接口，卖家由第三方作为参数传入。甲乙互相不依赖，而且只有在进行交易活动的时候，甲才和乙产生联系。反之亦然。这样做什么好处么呢，甲乙可以在对方不真实存在的情况下独立存在，而且保证不交易时候无联系，想交易的时候可以很容易的产生联系。甲乙交易活动不需要双方见面，避免了双方的互不信任造成交易失败的问题。因为交易由第三方来负责联系，而且甲乙都认为第三方可靠。那么交易就能很可靠很灵活的产生和进行了。这就是ioc的核心思想。生活中这种例子比比皆是，支付宝在整个淘宝体系里就是庞大的ioc容器，交易双方之外的第三方，提供可靠性可依赖可灵活变更交易方的资源管理中心。另外人事代理也是，雇佣机构和个人之外的第三方。
==========================update===========================

在以上的描述中，诞生了两个专业词汇，依赖注入和控制反转所谓的依赖注入，则是，甲方开放接口，在它需要的时候，能够讲乙方传递进来(注入)所谓的控制反转，甲乙双方不相互依赖，交易活动的进行不依赖于甲乙任何一方，整个活动的进行由第三方负责管理。

参考优秀的博文①：https://www.tianmaying.com/tutorial/spring-ioc

参考优秀的博文②：这里写链接内容

知乎@Intopass的回答：

不用自己组装，拿来就用。
享受单例的好处，效率高，不浪费空间。
便于单元测试，方便切换mock组件。
便于进行AOP操作，对于使用者是透明的。
统一配置，便于修改。
Spring模块
Spring可以分为6大模块：

Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系
Spring Web Spring对web模块的支持。

可以与struts整合,让struts的action创建交给spring
spring mvc模式
Spring DAO Spring 对jdbc操作的支持 【JdbcTemplate模板工具类】
Spring ORM spring对orm的支持：

既可以与hibernate整合，【session】
也可以使用spring的对hibernate操作的封装
Spring AOP 切面编程
SpringEE spring 对javaEE其他模块的支持
这里写图片描述

上面文主要引出了为啥我们需要使用Spring框架，以及大致了解了Spring是分为六大模块的....下面主要讲解Spring的core模块！

Core模块快速入门
搭建配置环境
引入jar包:

本博文主要是core模块的内容，涉及到Spring core的开发jar包有五个：

commons-logging-1.1.3.jar 日志
spring-beans-3.2.5.RELEASE.jar bean节点
spring-context-3.2.5.RELEASE.jar spring上下文节点
spring-core-3.2.5.RELEASE.jar spring核心功能
spring-expression-3.2.5.RELEASE.jar spring表达式相关表
我主要使用的是Spring3.2版本...

编写配置文件:

Spring核心的配置文件applicationContext.xml或者叫bean.xml

那这个配置文件怎么写呢？？一般地，我们都知道框架的配置文件都是有约束的...我们可以在spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html找到XML配置文件的约束

<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"
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">

</beans>
我是使用Intellij Idea集成开发工具的，可以选择自带的Spring配置文件,它长的是这样：

<?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模块的时候已经说了，Core模块是：IOC容器，解决对象创建和之间的依赖关系。

因此Core模块主要是学习如何得到IOC容器，通过IOC容器来创建对象、解决对象之间的依赖关系、IOC细节。

得到Spring容器对象【IOC容器】
Spring容器不单单只有一个，可以归为两种类型

Bean工厂，BeanFactory【功能简单】
应用上下文，ApplicationContext【功能强大，一般我们使用这个】
通过Resource获取BeanFactory
加载Spring配置文件
通过XmlBeanFactory+配置文件来创建IOC容器

//加载Spring的资源文件
Resource resource = new ClassPathResource("applicationContext.xml");

//创建IOC容器对象【IOC容器=工厂类+applicationContext.xml】
BeanFactory beanFactory = new XmlBeanFactory(resource);

类路径下XML获取ApplicationContext
直接通过ClassPathXmlApplicationContext对象来获取

// 得到IOC容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

System.out.println(ac);

在Spring中总体来看可以通过三种方式来配置对象:

使用XML文件配置
使用注解来配置
使用JavaConfig来配置
XML配置方式
在上面我们已经可以得到IOC容器对象了。接下来就是在applicationContext.xml文件中配置信息【让IOC容器根据applicationContext.xml文件来创建对象】

首先我们先有个JavaBean的类

/**
* Created by ozc on 2017/5/10.
*/
public class User {

private String id;
private String username;

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}
}
以前我们是通过new User的方法创建对象的....

User user = new User();
现在我们有了IOC容器，可以让IOC容器帮我们创建对象了。在applicationContext.xml文件中配置对应的信息就行了

<!--
使用bean节点来创建对象
id属性标识着对象
name属性代表着要创建对象的类全名
-->
<bean id="user" class="User"/>
通过IOC容器对象获取对象:

在外界通过IOC容器对象得到User对象

// 得到IOC容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

User user = (User) ac.getBean("user");

System.out.println(user);
这里写图片描述

上面我们使用的是IOC通过无参构造函数来创建对象，我们来回顾一下一般有几种创建对象的方式：

无参构造函数创建对象
带参数的构造函数创建对象
工厂创建对象

静态方法创建对象
非静态方法创建对象
使用无参的构造函数创建对象我们已经会了，接下来我们看看使用剩下的IOC容器是怎么创建对象的。

带参数的构造函数创建对象
首先，JavaBean就要提供带参数的构造函数：

public User(String id, String username) {
this.id = id;
this.username = username;
}
接下来，关键是怎么配置applicationContext.xml文件了。

<bean id="user" class="User">

<!--通过constructor这个节点来指定构造函数的参数类型、名称、第几个-->
<constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>
<constructor-arg index="1" name="username" type="java.lang.String" value="zhongfucheng"></constructor-arg>
</bean>
这里写图片描述

在constructor上如果构造函数的值是一个对象，而不是一个普通类型的值，我们就需要用到ref属性了，而不是value属性

比如说：我在User对象上维护了Person对象的值，想要在构造函数中初始化它。因此，就需要用到ref属性了

<bean id="person" class="Person"></bean>

<bean id="user" class="User" >

<!--通过constructor这个节点来指定构造函数的参数类型、名称、第几个-->
<constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>
<constructor-arg index="1" name="username" type="java.lang.String" ref="person"></constructor-arg>
</bean>
工厂静态方法创建对象
首先，使用一个工厂的静态方法返回一个对象

public class Factory {

public static User getBean() {

return new User();
}

}
配置文件中使用工厂的静态方法返回对象

<!--工厂静态方法创建对象，直接使用class指向静态类，指定静态方法就行了-->
<bean id="user" class="Factory" factory-method="getBean" >

</bean>
这里写图片描述

工厂非静态方法创建对象
首先，也是通过工厂的非非静态方法来得到一个对象

public class Factory {

public User getBean() {

return new User();
}

}
配置文件中使用工厂的非静态方法返回对象

<!--首先创建工厂对象-->
<bean id="factory" class="Factory"/>

<!--指定工厂对象和工厂方法-->
<bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>
这里写图片描述

c名称空间
我们在使用XML配置创建Bean的时候，如果该Bean有构造器，那么我们使用<constructor-arg>这个节点来对构造器的参数进行赋值...

<constructor-arg>未免有点太长了，为了简化配置，Spring来提供了c名称空间...

要想c名称空间是需要导入xmlns:c="http://www.springframework.org/schema/c"的

<bean id="userService" class="bb.UserService" c:userDao-ref="">

</bean>
c名称空间有个缺点：不能装配集合，当我们要装配集合的时候还是需要<constructor-arg>这个节点

装载集合
如果对象上的属性或者构造函数拥有集合的时候，而我们又需要为集合赋值，那么怎么办？

在构造函数上，普通类型

<bean id="userService" class="bb.UserService" >
<constructor-arg >
<list>
//普通类型
<value></value>
</list>
</constructor-arg>
</bean>
在属性上,引用类型

<property name="userDao">

<list>
<ref></ref>
</list>
</property>
注解方式
自从jdk5有了注解这个新特性，我们可以看到Struts2框架、Hibernate框架都支持使用注解来配置信息...

通过注解来配置信息就是为了简化IOC容器的配置，注解可以把对象添加到IOC容器中、处理对象依赖关系，我们来看看怎么用吧：

使用注解步骤：

1）先引入context名称空间

xmlns:context="http://www.springframework.org/schema/context"
2）开启注解扫描器

<context:component-scan base-package=""></context:component-scan>
第二种方法:也可以通过自定义扫描类以@CompoentScan修饰来扫描IOC容器的bean对象。。如下代码:

//表明该类是配置类
@Configuration

//启动扫描器，扫描bb包下的
//也可以指定多个基础包
//也可以指定类型
@ComponentScan("bb")
public class AnnotationScan {

}
在使用@ComponentScan()这个注解的时候，在测试类上需要@ContextConfiguration这个注解来加载配置类...

@ContextConfiguration这个注解又在Spring的test包下..
创建对象以及处理对象依赖关系，相关的注解：

@ComponentScan扫描器
@Configuration表明该类是配置类
@Component 指定把一个对象加入IOC容器--->@Name也可以实现相同的效果【一般少用】
@Repository 作用同@Component； 在持久层使用
@Service 作用同@Component； 在业务逻辑层使用
@Controller 作用同@Component； 在控制层使用
@Resource 依赖关系

如果@Resource不指定值，那么就根据类型来找，相同的类型在IOC容器中不能有两个
如果@Resource指定了值，那么就根据名字来找
测试代码:

UserDao
package aa;

import org.springframework.stereotype.Repository;

/**
* Created by ozc on 2017/5/10.
*/

//把对象添加到容器中,首字母会小写
@Repository
public class UserDao {

public void save() {
System.out.println("DB:保存用户");
}

}
userService

package aa;

import org.springframework.stereotype.Service;

import javax.annotation.Resource;

//把UserService对象添加到IOC容器中,首字母会小写
@Service
public class UserService {

//如果@Resource不指定值，那么就根据类型来找--->UserDao....当然了，IOC容器不能有两个UserDao类型的对象
//@Resource

//如果指定了值，那么Spring就在IOC容器找有没有id为userDao的对象。
@Resource(name = "userDao")
private UserDao userDao;

public void save() {
userDao.save();
}
}
userAction

package aa;

import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

/**
* Created by ozc on 2017/5/10.
*/

//把对象添加到IOC容器中,首字母会小写
@Controller
public class UserAction {

@Resource(name = "userService")
private UserService userService;

public String execute() {
userService.save();
return null;
}
}
测试

package aa;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* Created by ozc on 2017/5/10.
*/
public class App {

public static void main(String[] args) {

// 创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");

UserAction userAction = (UserAction) ac.getBean("userAction");

userAction.execute();
}
}
这里写图片描述

通过Java方式
由于Spring的自动装配并不能将第三方库组件装配到应用中，于是需要显式装配配置。显示装配有两种方式

通过java代码装配bean
通过XML装配bean
Spring In Action作者首推使用自动装配的功能，而后是通过java代码配置bean，最后才用XML文件配置的方式..

那么怎么通过java代码来配置Bean呢？？

编写一个java类，使用@Configuration修饰该类
被@Configuration修饰的类就是配置类
编写配置类:

@org.springframework.context.annotation.Configuration
public class Configuration {

}
使用配置类创建bean:

使用@Bean来修饰方法，该方法返回一个对象。
不管方法体内的对象是怎么创建的，Spring可以获取得到对象就行了。
Spring内部会将该对象加入到Spring容器中
容器中bean的ID默认为方法名

@org.springframework.context.annotation.Configuration
public class Configuration {

@Bean
public UserDao userDao() {

UserDao userDao = new UserDao();
System.out.println("我是在configuration中的"+userDao);
return userDao;
}

}
测试代码：要使用@ContextConfiguration加载配置类的信息【引入test包】

package bb;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;

/**
* Created by ozc on 2017/5/11.
*/
//加载配置类的信息
@ContextConfiguration(classes = Configuration.class)
public class Test2 {

@Test
public void test33() {

ApplicationContext ac =
new ClassPathXmlApplicationContext("bb/bean.xml");

UserDao userDao = (UserDao) ac.getBean("userDao");

System.out.println(userDao);
}
}
这里写图片描述

三种方式混合使用
注解和XML配置是可以混合使用的，JavaConfig和XML也是可以混合使用的...

如果JavaConfig的配置类是分散的，我们一般再创建一个更高级的配置类（root），然后使用@Import来将配置类进行组合
如果XML的配置文件是分散的，我们也是创建一个更高级的配置文件（root），然后使用<import>来将配置文件组合

在JavaConfig引用XML

使用@ImportResource()
在XML引用JavaConfig

使用<bean>节点就行了
bean对象创建细节
在Spring第一篇中，我们为什么要引入Spring提出了这么一些问题：

这里写图片描述

既然我们现在已经初步了解IOC容器了，那么这些问题我们都是可以解决的。并且是十分简单【对象写死问题已经解决了，IOC容器就是控制反转创建对象】

scope属性
指定scope属性，IOC容器就知道创建对象的时候是单例还是多例的了。

属性的值就只有两个：单例/多例

这里写图片描述

当我们使用singleton【单例】的时候，从IOC容器获取的对象都是同一个：
这里写图片描述

当我们使用prototype【多例】的时候，从IOC容器获取的对象都是不同的：
这里写图片描述

scope属性除了控制对象是单例还是多例的，还控制着对象创建的时间！

我们在User的构造函数中打印出一句话，就知道User对象是什么时候创建了。
public User() {

System.out.println("我是User，我被创建了");
}
当使用singleton的时候，对象在IOC容器之前就已经创建了

这里写图片描述
当使用prototype的时候，对象在使用的时候才创建

这里写图片描述
lazy-init属性
lazy-init属性只对singleton【单例】的对象有效.....lazy-init默认为false....

有的时候，可能我们想要对象在使用的时候才创建，那么将lazy-init设置为ture就行了

这里写图片描述

init-method和destroy-method
如果我们想要对象在创建后，执行某个方法，我们指定为init-method属性就行了。。

如果我们想要IOC容器销毁后，执行某个方法，我们指定destroy-method属性就行了。

<bean id="user" class="User" scope="singleton" lazy-init="true" init-method="" destroy-method=""/>
Bean创建细节总结

/**
* 1) 对象创建： 单例/多例
* scope="singleton", 默认值， 即 默认是单例 【service/dao/工具类】
* scope="prototype", 多例； 【Action对象】
*
* 2) 什么时候创建?
* scope="prototype" 在用到对象的时候，才创建对象。
* scope="singleton" 在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
* 3)是否延迟创建
* lazy-init="false" 默认为false, 不延迟创建，即在启动时候就创建对象
* lazy-init="true" 延迟初始化， 在用到对象的时候才创建对象
* （只对单例有效）
* 4) 创建对象之后，初始化/销毁
* init-method="init_user" 【对应对象的init_user方法，在对象创建之后执行 】
* destroy-method="destroy_user" 【在调用容器对象的destroy方法时候执行，(容器用实现类)】
*/
此文转载于知乎博主，原文链接如下：https://segmentfault.com/a/1190000013700859