前言
前面已经学习了Struts2和Hibernate框架了。接下来学习的是Spring框架…本博文主要是引入Spring框架…
Spring介绍Spring诞生:
侵入式概念
Spring是一种非侵入式的框架…
侵入式
非侵入式
松耦合
前面我们在写程序的时候,都是面向接口编程,通过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);"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来实现松耦合
而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); }
@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);
}
AOP编程可以简单理解成:在执行某些代码前,执行另外的代码
Spring也为我们提供更好地方式来实现面向切面编程!
引出Spring
我们试着回顾一下没学Spring的时候,是怎么开发Web项目的
用户访问:
我们来思考几个问题:
对于第一个问题和第三个问题,我们可以通过DaoFactory解决掉(虽然不是比较好的解决方法)
对于第二个问题,我们要控制对象的数量和创建事件就有点麻烦了….
而Spring框架通过IOC就很好地可以解决上面的问题….
IOC控制反转
Spring的核心思想之一:Inversion of Control , 控制反转 IOC
那么控制反转是什么意思呢???对象的创建交给外部容器完成,这个就做控制反转。
那么对象的对象之间的依赖关系Spring是怎么做的呢??依赖注入,dependency injection.
上面已经说了,控制反转是通过外部容器完成的,而Spring又为我们提供了这么一个容器,我们一般将这个容器叫做:IOC容器.
无论是创建对象、处理对象之间的依赖关系、对象创建的时间还是对象的数量,我们都是在Spring为我们提供的IOC容器上配置对象的信息就好了。
那么使用IOC控制反转这一思想有什么作用呢???我们来看看一些优秀的回答…
来自知乎:https://www.zhihu.com/question/23277575/answer/24259844
我摘取一下核心的部分:
ioc的思想最核心的地方在于,资源不由使用资源的双方管理,而由不使用资源的第三方管理,这可以带来很多好处。第一,资源集中管理,实现资源的可配置和易管理。第二,降低了使用资源双方的依赖程度,也就是我们说的耦合度。
也就是说,甲方要达成某种目的不需要直接依赖乙方,它只需要达到的目的告诉第三方机构就可以了,比如甲方需要一双袜子,而乙方它卖一双袜子,它要把袜子卖出去,并不需要自己去直接找到一个卖家来完成袜子的卖出。它也只需要找第三方,告诉别人我要卖一双袜子。这下好了,甲乙双方进行交易活动,都不需要自己直接去找卖家,相当于程序内部开放接口,卖家由第三方作为参数传入。甲乙互相不依赖,而且只有在进行交易活动的时候,甲才和乙产生联系。反之亦然。这样做什么好处么呢,甲乙可以在对方不真实存在的情况下独立存在,而且保证不交易时候无联系,想交易的时候可以很容易的产生联系。甲乙交易活动不需要双方见面,避免了双方的互不信任造成交易失败的问题。因为交易由第三方来负责联系,而且甲乙都认为第三方可靠。那么交易就能很可靠很灵活的产生和进行了。这就是ioc的核心思想。生活中这种例子比比皆是,支付宝在整个淘宝体系里就是庞大的ioc容器,交易双方之外的第三方,提供可靠性可依赖可灵活变更交易方的资源管理中心。另外人事代理也是,雇佣机构和个人之外的第三方。
==========================update===========================在以上的描述中,诞生了两个专业词汇,依赖注入和控制反转所谓的依赖注入,则是,甲方开放接口,在它需要的时候,能够讲乙方传递进来(注入)所谓的控制反转,甲乙双方不相互依赖,交易活动的进行不依赖于甲乙任何一方,整个活动的进行由第三方负责管理。
知乎@Intopass的回答:
-
不用自己组装,拿来就用。
-
享受单例的好处,效率高,不浪费空间。
-
便于单元测试,方便切换mock组件。
-
便于进行AOP操作,对于使用者是透明的。
-
统一配置,便于修改。
Spring模块
Spring可以分为6大模块:
这里写图片描述上面文主要引出了为啥我们需要使用Spring框架,以及大致了解了Spring是分为六大模块的….下面主要讲解Spring的core模块!
Core模块快速入门搭建配置环境
引入jar包:
本博文主要是core模块的内容,涉及到Spring core的开发jar包有五个:
我主要使用的是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>
</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>
<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容器不单单只有一个,可以归为两种类型
通过Resource获取BeanFactory
//加载Spring的资源文件 Resource resource = new ClassPathResource("applicationContext.xml"); //创建IOC容器对象【IOC容器=工厂类+applicationContext.xml】 BeanFactory beanFactory = new XmlBeanFactory(resource);
Resource resource = new ClassPathResource("applicationContext.xml");
//创建IOC容器对象【IOC容器=工厂类+applicationContext.xml】
BeanFactory beanFactory = new XmlBeanFactory(resource);
类路径下XML获取ApplicationContext
// 得到IOC容器对象 ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); System.out.println(ac);
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(ac);
在Spring中总体来看可以通过三种方式来配置对象:
XML配置方式
在上面我们已经可以得到IOC容器对象了。接下来就是在applicationContext.xml文件中配置信息【让IOC容器根据applicationContext.xml文件来创建对象】
/** * 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; }}
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;
}
}
User user = new User();
<!-- 使用bean节点来创建对象 id属性标识着对象 name属性代表着要创建对象的类全名 --> <bean id="user" class="User"/>
<bean id="user" class="User"/>
通过IOC容器对象获取对象:
// 得到IOC容器对象 ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); User user = (User) ac.getBean("user"); System.out.println(user);
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; }
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这个节点来指定构造函数的参数类型、名称、第几个-->
<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></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 Factory {
public static User getBean() {
return new User();
}
}
配置文件中使用工厂的静态方法返回对象
<!--工厂静态方法创建对象,直接使用class指向静态类,指定静态方法就行了--> <bean id="user" class="Factory" factory-method="getBean" > </bean>
<bean id="user" class="Factory" factory-method="getBean" >
</bean>
这里写图片描述工厂非静态方法创建对象
首先,也是通过工厂的非非静态方法来得到一个对象
public class Factory { public User getBean() { return new User(); }}class Factory {
public User getBean() {
return new User();
}
}
配置文件中使用工厂的非静态方法返回对象
<!--首先创建工厂对象--> <bean id="factory" class="Factory"/> <!--指定工厂对象和工厂方法--> <bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>
<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>
</bean>
c名称空间有个缺点:不能装配集合,当我们要装配集合的时候还是需要<constructor-arg>
这个节点
装载集合
如果对象上的属性或者构造函数拥有集合的时候,而我们又需要为集合赋值,那么怎么办?
<bean id="userService" class="bb.UserService" > <constructor-arg > <list> //普通类型 <value></value> </list> </constructor-arg> </bean>
<constructor-arg >
<list>
//普通类型
<value></value>
</list>
</constructor-arg>
</bean>
<property name="userDao"> <list> <ref></ref> </list> </property>
<list>
<ref></ref>
</list>
</property>
注解方式
自从jdk5有了注解这个新特性,我们可以看到Struts2框架、Hibernate框架都支持使用注解来配置信息…
通过注解来配置信息就是为了简化IOC容器的配置,注解可以把对象添加到IOC容器中、处理对象依赖关系,我们来看看怎么用吧:
使用注解步骤:
//表明该类是配置类@Configuration//启动扫描器,扫描bb包下的 //也可以指定多个基础包 //也可以指定类型@ComponentScan("bb")public class AnnotationScan {}
@Configuration
//启动扫描器,扫描bb包下的
//也可以指定多个基础包
//也可以指定类型
@ComponentScan("bb")
public class AnnotationScan {
}
在使用@ComponentScan()这个注解的时候,在测试类上需要@ContextConfiguration这个注解来加载配置类…
创建对象以及处理对象依赖关系,相关的注解:
测试代码:
package aa;import org.springframework.stereotype.Repository;/** * Created by ozc on 2017/5/10. *///把对象添加到容器中,首字母会小写@Repositorypublic class UserDao { public void save() { System.out.println("DB:保存用户"); }}
import org.springframework.stereotype.Repository;
/**
* Created by ozc on 2017/5/10.
*/
//把对象添加到容器中,首字母会小写
@Repository
public class UserDao {
public void save() {
System.out.println("DB:保存用户");
}
}
package aa;import org.springframework.stereotype.Service;import javax.annotation.Resource;//把UserService对象添加到IOC容器中,首字母会小写@Servicepublic class UserService { //如果@Resource不指定值,那么就根据类型来找--->UserDao....当然了,IOC容器不能有两个UserDao类型的对象 //@Resource //如果指定了值,那么Spring就在IOC容器找有没有id为userDao的对象。 @Resource(name = "userDao") private UserDao userDao; public void save() { userDao.save(); }}
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();
}
}
package aa;import org.springframework.stereotype.Controller;import javax.annotation.Resource;/** * Created by ozc on 2017/5/10. *///把对象添加到IOC容器中,首字母会小写@Controllerpublic class UserAction { @Resource(name = "userService") private UserService userService; public String execute() { userService.save(); return null; }}
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(); }}
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的自动装配并不能将第三方库组件装配到应用中,于是需要显式装配配置。显示装配有两种方式
Spring In Action作者首推使用自动装配的功能,而后是通过java代码配置bean,最后才用XML文件配置的方式..
那么怎么通过java代码来配置Bean呢??
编写配置类:
@org.springframework.context.annotation.Configuration public class Configuration { }
public class Configuration {
}
使用配置类创建bean:
@org.springframework.context.annotation.Configurationpublic class Configuration { @Bean public UserDao userDao() { UserDao userDao = new UserDao(); System.out.println("我是在configuration中的"+userDao); return userDao; }}
public class Configuration {
@Bean
public UserDao userDao() {
UserDao userDao = new UserDao();
System.out.println("我是在configuration中的"+userDao);
return userDao;
}
}
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); }}
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),然后使用来将配置文件组合
在JavaConfig引用XML
在XML引用JavaConfig
bean对象创建细节
在Spring第一篇中,我们为什么要引入Spring提出了这么一些问题:
这里写图片描述既然我们现在已经初步了解IOC容器了,那么这些问题我们都是可以解决的。并且是十分简单【对象写死问题已经解决了,IOC容器就是控制反转创建对象】
scope属性
指定scope属性,IOC容器就知道创建对象的时候是单例还是多例的了。
属性的值就只有两个:单例/多例
这里写图片描述这里写图片描述这里写图片描述scope属性除了控制对象是单例还是多例的,还控制着对象创建的时间!
public User() { System.out.println("我是User,我被创建了"); }
System.out.println("我是User,我被创建了");
}
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方法时候执行,(容器用实现类)】 */
如果文章有错的地方欢迎指正,大家互相交流。习惯在微信看技术文章,想要获取更多的Java资源的同学,可以关注微信公众号:Java3y