Spring入门介绍：

时间 2019-11-13

标签 spring 入门介绍栏目 Spring 繁體版

原文原文链接

Spring入门介绍
Spring诞生：html

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

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

侵入式spring

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

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

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

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

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

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

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="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文件了。

<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属性了

<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();
}

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

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