Spring3第一天

Spring第一天:IOC控制反转.

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

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

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

* web层:SpringMVC.

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

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

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

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

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

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

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

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应用难度大大降低

Spring3.x和Spring4.x

下载Spring的jar包:

目录结构:

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

* lib    :Spring开发的jar包

* schema :约束.

Spring框架的体系结构:

引入相应的jar包:

* beans、core、 context、 expression language.

* 引入日志的依赖jar包:

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

* 具体的日志解决log4j.

* 引入log4j.properties

创建包:

* cn.itcast.spring3.demo1

* 接口:UserService

* 实现类:UserServiceImpl

* 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>标签

<!-- bean标签: id :类起个别名    class:类的全路径 -->

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

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

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

* 面向对象的设计:

* 依赖:

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

* 聚合:hasa(有一个)

* 聚集:(紧密)

* 组合:(松散)

底层实现类:

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

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

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

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

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

国际化处理

事件传递

Bean自动装配

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

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

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

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

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

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

<!--Bean的实例化==========================begin-->

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

<bean>标签:

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

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

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

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

* spring整合struts1的时候:

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

通过<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>标签上init-method和destroy-method指定初始化和销毁执行的方法.

<!-- Bean的生命周期 -->

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

类:

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>

类:

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>

简化属性的注入:

* 如果类中有很多的属性,那么需要配置很多的<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>

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()}"/> <!--引用的是对象的某个方法-->

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>

第一种方式:

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

第二种方式:

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

注解的IOC的开发:

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

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

* @Component("userService")

引入一个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在后续版本会对其增强

普通属性:

* @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”)

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

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

在类上添加一个注解:

@Scope(“prototype”)

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框架可以扫描到注解:

编程测试程序:

XML:

* 结构清晰:

注解:

* 属性注入:

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

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

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

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

* @Autowired

* @Qualifer

XML和注解混合使用的话:

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

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

<!-- 开启注解的支持: -->

<context:annotation-config/>

在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);

步骤一:工程中有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单元测试: