今日内容
Spring框架的概述
Spring的快速入门
IoC容器装配Bean(xml配置方式)
Ioc容器装配Bean(注解方式)
在web项目中集成Spring
Spring 整合 junit4 测试
1.1 抽取工厂类:改造Struts+Hibernate的综合案例.
1.1.1 为什么要抽取工厂:
1.1.2 抽取工厂类:
步骤一:提供一个配置文件:
在src下创建一个applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="customerService" class="cn.itcast.sh.service.CustomerService"/>
<bean id="orderService" class="cn.itcast.sh.service.OrderService"/>
<bean id="customerDao" class="cn.itcast.sh.dao.CustomerDao"/>
<bean id="orderDao" class="cn.itcast.sh.dao.OrderDao"/>
</beans>
步骤二:编写一个工厂类:
publicclass BeanFactory {
publicstaticObject getBean(String id){
// 解析XML:可以使用DOM4J, pull (android) ,Jsoup(流行. ).
// WEB项目读取一个文件,使用ServletContext对象.使用类加载器ClassLoader读文件.
String path = BeanFactory.class.getClassLoader().getResource("applicationContext.xml").getFile();
try {
Document document = Jsoup.parse(new File(path), "UTF-8");
Elements elements = document.select("bean");
// 遍历每个bean标签
for (Element element : elements) {
// 判断:
if(id.equals(element.attr("id"))){
String classValue = element.attr("class");
// 反射生成这个类的实例:
Class clazz = Class.forName(classValue);
return clazz.newInstance();
}
}
} catch (Exception e) {
e.printStackTrace();
}
returnnull;
}
}
1.2 Spring的学习路线:
1.2.1 Spring的学习路线:
Spring的第一天:Spring的IOC.Spring的Bean管理.
Spring的第二天:Spring的AOP.Spring的JdbcTemplate.
Spring的第三天:Spring的事务管理.SSH的整合.
1.3 Spring的概述:
1.3.1 什么是Spring:
Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。
Expert One-to-One J2EE Design and Development :EE的开发.EJB.
Expert One-to-One J2EE Development without EJB :
分层:EE开发中三层结构.(一站式:Spring框架提供了EE开发每一层的解决方案.)
* WEB层:Spring MVC.
* 业务层:Spring的Bean管理.
* 持久层:Spring的JdbcTemplate ,orm模块用于整合其他的持久层框架.
1.3.2 为什么要学习Spring :
方便解耦,简化开发
Spring就是一个大工厂,可以将所有对象创建和依赖关系维护,交给Spring管理
AOP编程的支持
Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持
只需要通过配置就可以完成对事务的管理,而无需手动编程
方便程序的测试
Spring对Junit4支持,可以通过注解方便的测试Spring程序
方便集成各种优秀框架
Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接支持
降低JavaEE API的使用难度
Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低
1.3.3 Spring的版本:
Spring3.x 和 Spring4.x
1.4 Spring的IOC的快速入门:
1.4.1 Spring的快速入门:
步骤一:下载Spring的开发包:
http://repo.spring.io/webapp/search/artifact/?0&q=spring-framework
步骤二:了解Spring的目录结构:
docs :Spring的开发文档
libs :Spring的开发包.
schema :约束文档.
步骤三:创建一个项目,引入jar包:
步骤四:引入Spring的配置文件:
在src下创建一个applicationContext.xml
引入约束:
<beansxmlns="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>
编写标签:
<bean id="customerService" class="cn.itcast.spring.demo2.CustomerServiceImpl"></bean>
步骤五:编写测试类:
@Test
publicvoid demo1(){
// 创建Spring的工厂类:
ApplicationContext applicationContext = newClassPathXmlApplicationContext("applicationContext.xml");
CustomerService customerService = (CustomerService) applicationContext
.getBean("customerService");
customerService.sayHello();
}
1.4.2 IOC和DI:
IOC : Inverse of Control.控制反转.将Bean创建反转给Spring.
DI : Dependency Injection.依赖注入.在Spring创建这个类的过程中,将这个类的依赖的属性注入进去.
1.4.3 Spring的工厂类:
ApplicationContext
|----ClassPathXmlApplicationContext :解析类路径下的XML的.
|----FileSystemXmlApplicationContext :解析本地磁盘上的XML的.
BeanFactory和ApplicationContext都是Spring中的工厂:
BeanFactory是Spring老版本的工厂类:
* 第一次调用getBean方法的时候实例化类.
ApplicationContext是Spring新版本的工厂类:
* 在加载核心配置文件的时候,将所有的类实例化.
1.5 Spring的Bean管理(基于XML的方式)
1.5.1 Spring实例化Bean的方式(了解)
无参数构造方式(最常用)
<!-- 无参数构造方法方式 -->
<beanid="bean1"class="cn.itcast.spring.demo3.Bean1"></bean>
@Test
/**
* 无参数构造
*/
publicvoid demo1() {
// 加载核心配置文件:
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml");
Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");
System.out.println(bean1);
}
静态工厂实例化方式:
Bean2的静态工厂:
/**
* Bean2的静态工厂
* @authorjiangtao
*
*/
publicclass Bean2Factory {
publicstaticBean2 getBean2(){
returnnew Bean2();
}
}
配置文件:
<!-- 静态工厂实例化方式 -->
<beanid="bean2"class="cn.itcast.spring.demo3.Bean2Factory" factory-method="getBean2"/>
代码:
@Test
/**
* 静态工厂实例化
*/
publicvoiddemo2() {
// 加载核心配置文件:
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml");
Bean2 bean2 = (Bean2) applicationContext.getBean("bean2");
System.out.println(bean2);
}
实例工厂实例化方式:
实例工厂:
publicclass Bean3Factory {
public Bean3 getBean3(){
System.out.println("实例工厂执行了...");
returnnew Bean3();
}
}
配置文件:
<!-- 实例工厂实例化方式 -->
<beanid="bean3Factory"class="cn.itcast.spring.demo3.Bean3Factory"/>
<beanid="bean3"factory-bean="bean3Factory"factory-method="getBean3"/>
代码:
@Test
/**
* 实例工厂实例化
*/
publicvoiddemo3() {
// 加载核心配置文件:
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml");
Bean3 bean3 = (Bean3) applicationContext.getBean("bean3");
System.out.println(bean3);
}
1.5.2 Spring的Bean的常用的配置:
<bean>标签的id和name属性:
id和name有什么区别?
id :使用XML约束中ID约束.不可以出现特殊字符.
name:出现特殊字符.如果使用了name没有id,那么name可以作为id使用.
Spring整合Struts1: <bean name=”/login” class=””/>
<bean>上的生命周期的配置:
@Test
/**
* Bean的生命周期的相关配置:
* * init-method
* * destory-method :只能针对单例对象有效.必须在工厂关闭之后才会销毁对象.
*/
publicvoiddemo1(){
ClassPathXmlApplicationContext applicationContext = newClassPathXmlApplicationContext("applicationContext.xml");
EmployeeService employeeService = (EmployeeService) applicationContext
.getBean("employeeService");
employeeService.save();
applicationContext.close();
}
<bean>上的作用范围的配置:
scope属性:
* singleton :单例的.(默认)
* prototype :多例的.
* request :WEB项目中,创建一个对象,保存到request域中.
* session :WEB项目中,创建一个对象,保存到session域中.
* globalsession :WEB项目中,特殊环境.分布式开发环境.如果没有分布式环境,相当于session.
Bean的生命周期:
Spring实例化Bean的过程中总共完成11个步骤:
1.instantiate bean对象实例化
2.populate properties 封装属性
3.如果Bean实现BeanNameAware 执行 setBeanName
4.如果Bean实现BeanFactoryAware 或者 ApplicationContextAware 设置工厂 setBeanFactory 或者上下文对象 setApplicationContext
5.如果存在类实现 BeanPostProcessor(后处理Bean) ,执行postProcessBeforeInitialization
6.如果Bean实现InitializingBean 执行 afterPropertiesSet
7.调用<bean init-method="init"> 指定初始化方法 init
8.如果存在类实现 BeanPostProcessor(处理Bean) ,执行postProcessAfterInitialization
9.执行业务处理
10.如果Bean实现 DisposableBean 执行 destroy
11.调用<bean destroy-method="customerDestroy"> 指定销毁方法 customerDestroy
第三步和第四步:主要让生成Bean了解Spring容器.
第五步和第八步:允许客户在Bean的生成过程中对Bean的实例进行增强.
* BeanPostProcessor:工厂勾子.允许客户在生成类的过程中对类进行增强.
1.5.3 Spring的属性注入:
构造方法的属性注入:
<!-- 构造方法的注入 -->
<beanid="car"class="cn.itcast.spring.demo6.Car">
<constructor-argname="name"value="宝马"/>
<constructor-argname="price" value="1000000"/>
</bean>
Set方法的属性注入:
<!-- set方法的属性注入 -->
<beanid="car2"class="cn.itcast.spring.demo6.Car2">
<propertyname="name"value="奇瑞QQ"/>
<propertyname="price"value="30000"/>
</bean>
1.5.4 Spring的2.5支持p名称空间的注入:
P名称空间的语法:
语法:
* 普通属性: p:name=””
* 对象类型属性: p:name-ref=””
P名称空间的使用:
引入p名称空间:
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
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">
<!-- p名称空间的注入 -->
<beanid="car2" class="cn.itcast.spring.demo6.Car2" p:name="长安奔奔" p:price="25000"/>
<bean id="employee" class="cn.itcast.spring.demo6.Employee" p:name="马凤" p:car2-ref="car2"/>
1.5.5 Spring3.0的SpEL的属性注入(SpEL:Spring Expression Language)
SpEL的语法:
语法:#{SpEL}
SpEL的用法:
<beanid="carInfo" class="cn.itcast.spring.demo6.CarInfo">
</bean>
<!-- SpEL的方式的属性注入 -->
<beanid="car2" class="cn.itcast.spring.demo6.Car2">
<propertyname="name" value="#{carInfo.carName}"/>
<propertyname="price" value="#{carInfo.calculatorPrice()}"/>
</bean>
<beanid="employee" class="cn.itcast.spring.demo6.Employee">
<propertyname="name" value="涛哥"/>
<propertyname="car2" value="#{car2}"/>
</bean>
1.5.6 Spring中的数组或集合的属性的注入:
数组属性的注入:
<property name="arrs">
<list>
<value>老马</value>
<value>马凤</value>
<value>马如花</value>
</list>
</property>
List集合的属性的注入:
<property name="list">
<list>
<value>马芙蓉</value>
<value>马大帅</value>
<value>马大彪</value>
</list>
</property>
Set集合的属性的注入:
<property name="set">
<set>
<value>马云</value>
<value>马化腾</value>
<value>马大哈</value>
</set>
</property>
Map集合的属性的注入:
<property name="map">
<map>
<entry key="aaa"value="刘能"/>
<entry key="bbb"value="赵四"/>
<entry key="ccc"value="王五"/>
</map>
</property>
Properties的属性的注入:
<propertyname="properties">
<props>
<propkey="username">root</prop>
<propkey="password">123</prop>
</props>
</property>
1.5.7 Spring中的分配置文件进行开发:
加载配置文件的时候加载多个配置文件:
@Test
/**
* 在加载配置文件的时候,加载多个配置文件
*/
publicvoiddemo2() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml", "applicationContext2.xml");
CollectionBean collectionBean = (CollectionBean) applicationContext
.getBean("collectionBean");
System.out.println(collectionBean);
}
总配置文件中引入其他配置文件:
<import resource="applicationContext2.xml"/>
@Test
/**
* 在一个配置文件中引入其他的配置文件
*/
publicvoiddemo3() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml");
CollectionBean collectionBean = (CollectionBean) applicationContext
.getBean("collectionBean");
System.out.println(collectionBean);
}
1.6 Spring的Bean管理(基于注解方式)
1.6.1 Spring的注解的快速入门:
步骤一:创建项目,引入jar包:
步骤二:引入spring的配置文件:
如果使用Spring的注解的开发,需要引入context约束!!!
<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">
步骤三:创建包和类:
* cn.itcast.spring.demo1
* UserService
* UserServiceImpl
步骤四:在类上配置一个注解:
@Component(value="userService")
相当于:
<bean id=”userService” class=”…UserServiceImpl”/>
步骤五:在Spring中开启注解扫描:
<context:component-scan base-package="cn.itcast.spring.demo1"/>
1.6.2 Spring的IOC的注解详解:
@Component:组件.
Spring提供了@Component的注解的一些衍生注解:
* @Controller :
* @Service :
* @Repository :
@Value:注入普通类型的属性.
@Value(value=”张三”)
private String name;
@Autowired
默认按类型完成属性的注入:
* 但是我们习惯采用按名称注入.
* 强制使用按名称的方式完成属性的注入:
* @Qulifer(value=”名称”)
@Resource:
@Resource注解相当于:
* @Autowired和@Qulifer一起使用完成按名称的属性注入.
1.6.3 Spring的IOC的其他的注解:
@PostConstruct:
相当于init-method
@PreDestory:
相当于destory-method
@Scope:
相当于scope属性:
* singleton
* prototype
* request
* session
* globalSession
1.6.4 Spring3.0基于JavaConfig为核心的注解(了解)
以JavaConfig为核心:使用Java类作为配置文件.
* 类的构造特别麻烦!!!
@Configuration
publicclass BeanConfig {
@Bean(name="car")
public Car showCar(){
Car car = new Car();
car.setName("马自达");
car.setPrice(150000d);
return car;
}
@Bean(name="product")
public Product showProduct(){
Product product = new Product();
product.setName("空调");
product.setPrice(1200d);
return product;
}
}
1.6.5 XML和注解的比较:
XML:结构清晰.(Bean管理由Spring控制.)
注解:开发便捷.(属性注入:不需要提供set方法.)
企业中通常还有一种开发方式:XML和注解的整合开发.
* XML用于管理Bean.
* 注解用于属性注入.
需要在配置文件中开启注解配置:
<context:annotation-config/>
把Bean交给Spring进行管理.属性注入由注解完成.