Spring3第一天

l Spring框架的概述

l Spring的快速入门

l IoC容器装配Bean（xml配置方式）

l Ioc容器装配Bean（注解方式）

l 在web项目中集成Spring

l Spring 整合 junit4 测试

1.1 Spring的学习路线:

Spring第一天:IOC控制反转.

Spring第二天:AOP面向切面编程.

Spring第三天:声明式事务管理,SSH整合.

1.2 Spring框架的概述:

1.2.1 什么是Spring:

Spring是分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架

* web层:SpringMVC.

* 业务层:Bean管理,声明式事务.

* 持久层:SpringJDBCTemplate,Spring的ORM模块(整合其他的持久层框架)

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Developmentand Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。

1.2.2 Spring的核心:

*Spring核心是IOC(控制反转) 和 AOP(面向切面编程)

1.2.3 Spring的由来:

*SUN公司提供的EE的解决方案:EJB

2002 Expert One-to-One J2EE Design and Development (EJB用途)

2004ExpertOne-to-One J2EE Development without EJB (阐述EE开发需要什么)

1.2.4 为什么要学习Spring:(好处)

1.方便解耦，简化开发

Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理

2.AOP编程的支持

Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能

3.声明式事务的支持

只需要通过配置就可以完成对事务的管理，而无需手动编程

4.方便程序的测试

Spring对Junit4支持，可以通过注解方便的测试Spring程序

5.方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持

6.降低JavaEE API的使用难度

Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

1.2.5 Spring版本:

Spring3.x和Spring4.x

1.3 Spring框架快速入门:

1.3.1 Spring的快速入门:

步骤一:下载Spring的开发的jar包:

下载Spring的jar包:

目录结构:

* docs :API文档和Spring的开发规范.

* lib :Spring开发的jar包

* schema :约束.

Spring框架的体系结构:

步骤二:创建工程引入相应的jar包:

引入相应的jar包:

* beans、core、 context、 expression language.

* 引入日志的依赖jar包:

* commons-logging.jar包:类似于slf4j.jar(用于整合其他日志)

* 具体的日志解决log4j.

* 引入log4j.properties

步骤三:编程实现Spring的IOC.

创建包:

* cn.itcast.spring3.demo1

* 接口:UserService

* 实现类:UserServiceImpl

步骤四:在src下创建一个:

* applicationContext.xml

* 引入约束:

*spring-framework-3.2.0.RELEASE\docs\spring-framework-reference\html\xsd-config.html

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

* 配置一个<bean>标签

<beanid="userService"class="cn.itcast.spring3.demo1.UserServiceImpl"></bean>

步骤五:编写测试类:

@Test
// Spring的IOC容器:
public void demo2(){// 工厂 + 反射+ 配置文件// 创建工厂ApplicationContextapplicationContext = newClassPathXmlApplicationContext("applicationContext.xml");// 通过工厂获得类:UserServiceuserService = (UserService) applicationContext.getBean("userService");userService.sayHello();
}

1.3.2 (*****)控制反转(IOC)和依赖注入(DI)的区别

IOC:控制反转.将对象的创建权,反转到了Spring.

DI:依赖注入.Spring创建对象的过程中,把这个对象所依赖的对象注入(设置)进来.

* 面向对象的设计:

* 依赖:

public class A{
private B b;
}
* 继承:isa(是一个)
Public class A{
}
Public class B extends A{
}

* 聚合:hasa(有一个)

* 聚集:(紧密)

* 组合:(松散)

1.3.3 ApplicationContext对象的实现类:

底层实现类:

* ClassPathXmlApplicationContext :加载类路径下:Spring的配置文件.获得Bean的信息.

* FileSystemXmlApplicationContext :加载磁盘路径下:Spring的配置文件.

1.3.4 BeanFactory和ApplicationContext的关系:

在早期开发中,可以使用BeanFactory获得类.

BeanFactory采取延迟加载，第一次getBean时才会初始化Bean

ApplicationContext是对BeanFactory扩展，提供了更多功能

国际化处理

事件传递

Bean自动装配

各种不同应用层的Context实现.

1.3.5 MyEclipse配置Spring提示:

Window--->preferences---->搜索xml catalog

1.4 装配Bean(XML)

1.4.1 Bean的实例化:(了解)

Spring框架创建Bean.有几种创建的形式?

* 第一种:使用类的默认构造器的方式:(默认使用)

* 第二种:使用静态工厂实例化.

* 第三种:使用实例工厂实例化.

默认无参数构造方法:

<bean id="bean1"class="cn.itcast.spring3.demo2.Bean1"></bean>

使用静态工厂实例化类:

<bean id="bean2"class="cn.itcast.spring3.demo2.Bean2Factory"factory-method="getBean2"></bean>

使用实例工厂实例化:

<bean id="bean3Factory"class="cn.itcast.spring3.demo2.Bean3Factory"></bean>
<bean id="bean3"factory-bean="bean3Factory"factory-method="getBean3"></bean>

1.4.2 Bean的其他的配置:

id和name的配置:

<bean>标签:

* id属性:id的命名要满足XML对ID属性命名规范必须以字母开始，可以使用字母、数字、连字符、下划线、句话、冒号

** id中一般认为不可出现特殊字符.唯一的.

* name属性:可以出现特殊字符的.没有唯一的要求(唯一的).

***** 如果元素上没有id只有name,那么这个name属性可以被作为id使用.

* spring整合struts1的时候:

* <bean name=”/login” class=”...UserAction”/> :这种写法中有一个 / 特殊字符,这个时候如果使用 id的话.报错.

Bean的作用范围:

通过<bean>标签上scope属性配置类的作用范围:

* singleton :Spring框架创建Bean的时候,使用单例这种模式.

* prototype :Spring框架创建Bean的时候,采用多例的.

* request :web项目中,创建一个Bean对象,将Bean的对象存到request范围. @当声明为request的时候其实就是声明要保存的东西存储到request的域中，当取得时候直接从request域中获得就可以了。

* session :web项目中,创建一个Bean对象,将Bean的对象存到session范围.

* globalsession :一般用于Porlet应用环境.(分布式环境.)如果没有这种环境,globalsession和session是等价的.

***** 开发中经常使用的是singleton和prototype.

Bean的生命周期:

生命周期:这个类从创建到销毁过程.

* 通过<bean>标签上init-method和destroy-method指定初始化和销毁执行的方法.

<beanid="userDao" class="cn.itcast.spring3.demo4.UserDaoImpl" init-method="setup" destroy-method="teardown"></bean>

***** 销毁的方法执行,必须bean是单例的而且关闭工厂.

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.调用<beaninit-method="init"> 指定初始化方法 init

8.如果存在类实现 BeanPostProcessor（后处理Bean），执行postProcessAfterInitialization

9.执行业务处理

10.如果Bean实现 DisposableBean 执行 destroy

11.调用<beandestroy-method="customerDestroy"> 指定销毁方法 customerDestroy

* 第三步和第四步让Bean了解Spring容器.

***** BeanPostProcessor:工厂勾子.允许用户对其进行扩展.

* 每个类在实例的时候,后处理Bean都会执行.对这个类进行扩展.

* 扩展有几种方式?

* 继承:

* 装饰者模式:

* 动态代理:

* 后处理Bean通常与动态代理一起使用,完成Bean的增强的操作.(Spring中有很多的地方都使用了后处理Bean).

* 对UserDao中的add方法进行权限校验/时间监控?

* Proxy:

* static Object newProxyInstance(ClassLoaderclassLoader,Class[] interfaces,InvocationHandler h);

1.4.3 IOC容器DI操作:

构造方法的注入:

类:

publicclass Car {
private String name;
private double price;
public Car(String name,double price){this.name= name;this.price= price;
}
}

配置:

<bean id="car"class="cn.itcast.spring3.demo5.Car"><constructor-argname="name" value="宝马"/><constructor-argname="price" value="1000000"/>
</bean>

或者配置成:

<!-- 属性的注入 -->
<bean id="car"class="cn.itcast.spring3.demo5.Car"><constructor-argindex="0" type="java.lang.String" value="宝马"/><constructor-argindex="1" type="double" value="1000000"/>
</bean>

Set方法注入:(*****)

类:

public class Car2 {
private Stringname;
private doubleprice;
public voidsetName(String name) {this.name = name;
}
public voidsetPrice(double price) {this.price = price;
}
}

配置:

<beanid="car2" class="cn.itcast.spring3.demo5.Car2"><!-- set方法注入: --><property name="name"value="奔驰"/><property name="price"value="1100000"/>
</bean>

***** value注入的是普通属性.ref注入的是依赖的其他Bean.

<bean id="car2"class="cn.itcast.spring3.demo5.Car2"><!-- set方法注入: --><property name="name" value="电驴" /><property name="price"value="2000"/>
</bean><beanid="person" class="cn.itcast.spring3.demo5.Person"><property name="name"value="刘跃东"/><property name="car2" ref="car2"/>
</bean>

1.4.4 名称空间p的注入:

简化属性的注入:

* 如果类中有很多的属性,那么需要配置很多的<property>标签,那么这样的话,就会比较麻烦.

Spring2.5版本以后提供名称空间p的注入形式:

* 语法:

* p:属性名=”值”

* p:属性名-ref=”对象”

步骤一:引入名称空间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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">

步骤二:改写配置文件:

<bean id="person"class="cn.itcast.spring3.demo5.Person"><property name="name"value="刘跃东"/><property name="car2" ref="car2"/>
</bean>

使用名称空间p之后:

<bean id="person"class="cn.itcast.spring3.demo5.Person" p:name="刘跃东"p:car2-ref="car2"></bean>

1.4.5 SpEL注入:

SPEL:Springexpression language(Spring 3.0中提供新的特性:)

语法:

* #{SpEL}

<property name="name"value="#{carInfo.name}" />     <!--引用是另一个对象的name属性-->
<property name="price"value="#{20000}"/>    <!--引用的是普通的值-->
<property name="price"value="#{carInfo.countMoney()}"/> <!--引用的是对象的某个方法-->

1.4.6 注入集合属性:

List
* <propertyname="list"><list><value>宝马</value><value>奔驰</value></list></property>Set
* <propertyname="set"><set><value>刘跃东</value><value>梁桐</value></set></property>Map
* <propertyname="map"><map><entrykey="刘跃东"value="250"/><entrykey="梁同"value="380"/></map></property>Properties
* <propertyname="properties"><props><propkey="刘跃东">250</prop><propkey="梁同">380</prop></props></property>

1.4.7 Spring支持多文件的配置:

第一种方式:

* ApplicationContext applicationContext = newClassPathXmlApplicationContext("bean1.xml","bean2.xml");

第二种方式:

* <importresource="classpath:applicationContext2.xml"/>

1.5 装配Bean(基于注解)

1.5.1 注解的方式装配Bean

注解的IOC的开发:

步骤一:引入spring开发的jar包:

注解的开发引入的jar和xml方式的开发的jar包相同.

步骤二:创建包和类:

步骤三:注解开发:

在编程的Service的类上添加一个注解;

* @Component("userService")

步骤四:在src下创建一个applicationContext.xml

引入一个context的头约束:

<beansxmlns="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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd">

配置spring框架扫描的包:

<context:component-scanbase-package="cn.itcast.spring3.demo1"/>

步骤五:编写测试类:

@Test

public void demo1() {ApplicationContextapplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");UserServiceuserService = (UserService) applicationContext.getBean("userService");userService.sayHello();
}

补充:

提供了@Component的三个衍生注解:

* web层:@Controller

* 业务层:@Service

* DAO层:@Repository

这三个注解是为了让标注类本身的用途清晰，Spring在后续版本会对其增强

1.5.2 注解完成属性的注入:

普通属性:

* @Value的注解:

@Value(“itcast”)

private String info;

对象属性:

* @Autowired的注解:

@Autowired

private UserDaouserDao;

* @Autowired注解:默认按类型装配.

* @Qualifier注解和@Autowired注解组合使用 按名称进行装配.

***** 注解的属性的注入:可以没有set方法. @Value/@Autowired 注解可以修饰成员变量,修饰set方法.如果修饰了成员变量,可以不用提供set方法.

Sprin提供了对JSR-250(标准)的支持:

@Resource(name="userDao")

* 相当于

@Autowired

@Qualifer(“userDao”)

1.5.3 Bean的生命周期:

@PostConstruct 相当于<bean init-method=””>

@PreDestroy 相当于<bean destroy-method=””>

1.5.4 Bean的作用范围:

在类上添加一个注解:

@Scope(“prototype”)

1.5.5 Spring3.0以JavaConfig为核心，提供使用Java类定义Bean信息的方法(很少使用)

JavaConfig:用一个Jave类作为一个配置.

定义一个类:让这个类作为配置(工厂)

@Configuration
public class BeanConfig {
@Bean(name="car")
public CarshowCar(){Car car = new Car();car.setName("保时捷");car.setPrice(2000000);return car;
}
@Bean(name="product")
public ProductshowProduct(){Product product = new Product();product.setName("空调");product.setPrice(2000);return product;
}
}

让Spring框架可以扫描到注解:

编程测试程序:

1.5.6 企业开发中使用XML还是注解:

XML:

* 结构清晰:

注解:

* 属性注入:

结合XML和注解方式:(混合使用)

* bean的管理一般都交给XML配置.

* <bean id=”” class=””>

* bean的属性注入一般采用注解.

* @Autowired

* @Qualifer

XML和注解混合使用的话:

* Bean在XML中配置,Bean的属性由注解的方式注入:

* 需要开启一个注解的支持:

<context:annotation-config/>

1.6 Spring在web项目中使用:

在Servlet中编写如下代码:

public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {ApplicationContextapplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");UserServiceuserService = (UserService)applicationContext.getBean("userService");userService.add();
}

发现一个问题:

* 每次执行Servlet的时候,都会创建一个Spring的工厂(加载Spring的环境.)只需要加载一次就可以了!!!

* 解决方案一:可以把加载Spring的环境的代码放到Servlet的init方法中.

***** 一个Servlet中可以使用没有问题的,如果有很多的Servlet.

* 解决方案二:ServletContext.全局对象.服务器启动的时候创建.

* 将Spring的工厂放到ServletContext中.

* ServletContextListener:监听ServletContext对象的创建和销毁.

* 需要引入:spring-web-3.2.0.RELEASE.jar

* 配置监听器:

<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>

* 配置初始化参数:

 <context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param>

* 改写Servlet:

第一种方式:

WebApplicationContext applicationContext =WebApplicationContextUtils.getWebApplicationContext(getServletContext());

另一种方式:

WebApplicationContext applicationContext =(WebApplicationContext)getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

1.7 Spring整合JUnit单元测试:

步骤一:工程中有Junit的开发环境.

步骤二:导入spring-test-3.2.0.RELEASE.jar

步骤三:在测试类中添加注解:

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class SpringTest1 {

@Autowired

@Qualifier("userService")

privateUserService userService;

@Test

public voiddemo1(){

userService.add();

}

今天的内容总结:

IOC:

* Spring的概述:

* Spring一站式框架有EE开发中每一层的解决方案:

* web:Spring MVC

* service:bean管理事务

* dao:JdbcTemplate orm模块

* Spring的快速入门:

* 引入包:

* beans,core,context,expression

* 整合日志jar包.

* 创建包和类:

* HelloService

* 将这个类配置到Spring的配置文件中:

* <bean id=”” class=””/>

* 编写测试类:

* 获得工厂类:

* 通过工厂获得类:

* 调用业务方法:

* IOC:底层实现原理:工厂+反射+配置文件.

* IOC和DI区别:

* IOC:控制反转:将对象的创建权交给(反转给)Spring

* DI:依赖注入:在Spring创建这个类的过程中,将这个类依赖的对象注入进来.

* Spring中IOC(Bean的装配)

* XML:

* id name scope init-methoddestroy-method

* scope:

* singleton

* prototype

* 实例化方式:

* 三种:(了解)

* 属性注入 :

* 构造方法:

* set方法:

* Spring2.5中提供p名称空间注入:

* Spring3.0中提供SpEL注入:

* 注解:

* 定义类:

* 引入context约束:

* 在类上添加@Component注解:

* 衍生注解:

* @Controller

* @Service

* @Repository

* 配置spring配置文件扫描类上的注解:

* 属性注入:

* 普通属性:

* @Value

* 对象属性:

* @Autowired

* @Qualifer

* 衍生注解@Resource

* @Scope

XML和注解可以结合使用:

* 开启注解的支持:

* Bean一般在XML中配置:

* 属性注解的注入:

* Spring整合web项目:

* Spring整合JUnit单元测试: