1.1 Spring框架学习路线:
Spring的Ioc
Spring的AOP , AspectJ
Spring的事务管理 , 三大框架的整合.
1.2 Spring框架的概述:
1.2.1 什么是Spring:
Spring是分层的JavaSE/EE full-stack(一站式) 轻量级开源框架
* 分层:
* SUN提供的EE的三层结构:web层、业务层、数据访问层(持久层,集成层)
* Struts2是web层基于MVC设计模式框架.
* Hibernate是持久的一个ORM的框架.
* 一站式:
* Spring框架有对三层的每层解决方案:
* web层:Spring MVC.
* 持久层:JDBC Template
* 业务层:Spring的Bean管理.
1.2.2 Spring的核心:
IOC:(Inverse of Control 反转控制)
* 控制反转:将对象的创建权,交由Spring完成.
AOP:Aspect OrientedProgramming 是 面向对象的功能延伸.不是替换面向对象,是用来解决OO中一些问题.
IOC:控制反转.
web层需要调sevice,sevice需要调用Dao,
面向对象:面向接口的方式编程(为了方便扩展)
1.2.3 Spring的版本:
Spring3.x和Spring4.x Spring4需要整合hibernate4.
1.2.4 EJB:企业级JavaBean
EJB:SUN公司提出EE解决方案.
2002 : Expert One-to-One J2EE Design and Development
2004 : Expert One-to-One J2EE Development without EJB (EE开发真正需要使用的内容.)
1.2.5 Spring优点:
方便解耦,简化开发
* Spring就是一个大工厂,可以将所有对象创建和依赖关系维护,交给Spring管理
AOP编程的支持
* Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持
* 只需要通过配置就可以完成对事务的管理,而无需手动编程
方便程序的测试
* Spring对Junit4支持,可以通过注解方便的测试Spring程序
方便集成各种优秀框架
* Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接支持
降低JavaEEAPI的使用难度
* Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低
1.3 Spring的入门的程序:
1.3.1 下载Spring的开发包:
spring-framework-3.2.0.RELEASE-dist.zip ---Spring开发包
* docs :spring框架api和规范
* libs :spring开发的jar包
*schema :XML的约束文档.
spring-framework-3.0.2.RELEASE-dependencies.zip ---Spring开发中的依赖包
1.3.2 创建web工程引入相应jar包:
spring-beans-3.2.0.RELEASE.jar
spring-context-3.2.0.RELEASE.jar
spring-core-3.2.0.RELEASE.jar
spring-expression-3.2.0.RELEASE.jar
开发的日志记录的包:
com.springsource.org.apache.commons.logging-1.1.1.jar --- 用于整合其他的日志的包(类似Hibernate中slf4j)
com.springsource.org.apache.log4j-1.2.15.jar
Spring框架是一个分层架构,,它包含一系列的功能要素并被分为大约20个模块。这些模块分为CoreContainer、DataAccess/Integration、Web、AOP(AspectOriented Programming)、Instrumentation和测试部分,如下图所示:
1.3.3 创建Spring的配置文件:
在src下创建一个applicationContext.xml
引入XML的约束:
* 找到xsd-config.html.引入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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">
1.3.4 在配置中配置类:
<bean id="userService"class="cn.itcast.spring3.demo1.HelloServiceImpl"></bean>
1.3.5 创建测试类:
@Test
// Spring开发
public void demo2() {
// 创建一个工厂类.
ApplicationContextapplicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml");
HelloService helloService =(HelloService) applicationContext.getBean("userService");
helloService.sayHello();
}
1.3.6 IOC和DI(*****)区别?
IOC:控制反转:将对象的创建权,由Spring管理.(例如:hellosevice不需要自己创建)(创建对象)
DI:依赖注入:在Spring创建对象的过程中,把对象依赖的属性注入到类中.(创建对象的时候依赖的属性注入进来)
IoCInverse of Control 反转控制的概念,就是将原本在程序中手动创建HelloService对象的控制权,交由Spring框架管理,简单说,就是创建HelloService对象控制权被反转到了Spring框架
DI:DependencyInjection 依赖注入,在Spring框架负责创建Bean对象时,动态的将依赖对象注入到Bean组件
* 面向对象中对象之间的关系;
* 依赖:
public class A{
private B b;
}
* 继承:is a
* 聚合:
* 聚集:(紧密的聚集关系(身体各个部分))
* 组合:(松散的聚集关系(电视机与遥控器))
<!-- 通过一个<bean>标签设置类的信息,通过id属性为类起个标识. -->
<bean id="userService" class="cn.itcast.spring3.demo1.HelloServiceImpl">
<!-- 使用<property>标签注入属性 -->(依赖注入,把对象依赖的属性注入到类中.)
<property name="info" value="播客(磁盘路径)"/>
</bean>
1.3.7 Spring框架加载配置文件:
ApplicationContext 应用上下文,加载Spring 框架配置文件
加载classpath:
new ClassPathXmlApplicationContext("applicationContext.xml"); :加载classpath下面配置文件.
加载磁盘路径:
new FileSystemXmlApplicationContext("applicationContext.xml"); :加载磁盘下配置文件.
@Test
// Spring开发 加载classpath下的配置文件
public void demo2() {
// 创建一个工厂类.
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml");
HelloService helloService = (HelloService) applicationContext
.getBean("userService");
helloService.sayHello();
}
@Test
// 加载磁盘路径下的配置文件:
public void demo3() {
ApplicationContext applicationContext = new FileSystemXmlApplicationContext(
"applicationContext.xml");
HelloService helloService = (HelloService) applicationContext
.getBean("userService");
helloService.sayHello();
}
1.3.8 BeanFactory与ApplicationContext区别?
ApplicationContext类继承了BeanFactory.
BeanFactory在使用到这个类的时候,getBean()方法的时候才会加载这个类.(BeanFactory 采取延迟加载,第一次getBean时才会初始化Bean)
ApplicationContext类加载配置文件的时候,创建所有的类.
ApplicationContext对BeanFactory提供了扩展:
* 国际化处理
* 事件传递
* Bean自动装配
* 各种不同应用层的Context实现
***** 早期开发使用BeanFactory.
BeanFactory factory = new XmlBeanFactory(newClassPathResource("applicationContext.xml"));
HelloService helloService= (HelloService)factory.getBean("helloService");
helloService.sayHello();
@Test
public void demo4(){
// ClassPathResource FileSystemResource
BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource("applicationContext.xml"));
HelloService helloService = (HelloService) beanFactory.getBean("userService");
helloService.sayHello();
}
1.3.9 MyEclipse配置XML提示:
Window--->xmlcatalog--->add 找到schema的位置 ,将复制的路径 copy指定位置,选择schema location.
方案一: 联网下载
http://www.springframework.org/schema/beans/spring-beans.xsd
方案二: 采用本地schema配置
Myeclipse window-preferences- 搜索xml catalog
选中User Specified Entries -- Add 操作
location 浏览选中 解压spring 包中 schema\beans\spring-beans-3.2.xsd
修改Key type 为 Schema location
key 修改为 http://www.springframework.org/schema/beans/spring-beans.xsd
点击OK
1.4 IOC装配Bean:
1.4.1 Spring框架Bean实例化的方式:
提供了三种方式实例化Bean.
* 构造方法实例化:(默认无参数)(类构造器实例化)(推荐)
<!-- 默认情况下使用的就是无参数的构造方法. -->
<bean id="bean1" class="cn.itcast.spring3.demo2.Bean1"></bean>
public class Bean1 {
public Bean1(){
}
}
// 无参数的构造方法的实例化
public void demo1() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml");//先加载配置文件
Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");//通过key获得,这时候就能实例化
System.out.println(bean1);//输出具体地址
}//带参报错
* 静态工厂实例化(简单工厂模式):
<!-- 第二种使用静态工厂实例化 -->
<bean id="bean2" class="cn.itcast.spring3.demo2.Bean2Factory" factory-method="getBean2"></bean>(类型.(点)
Bean2Factory(因为静态方法))
public class Bean2 {
}
public class Bean2Factory {
public static Bean2 getBean2(){
System.out.println("静态工厂的获得Bean2的方法...");
return new Bean2();
}
}
* 实例工厂实例化(工厂方法模式):
<!-- 第三种使用实例工厂实例化 -->
<bean id="bean3" factory-bean="bean3Factory"factory-method="getBean3"></bean>(factory-bean指向工厂)
<bean id="bean3Factory" class="cn.itcast.spring3.demo2.Bean3Factory"/>(先实例化bean3Factory)
public class Bean3 {
}
public class Bean3Factory {
public Bean3 getBean3(){
System.out.println("Bean3实例工厂的getBean3方法...");
return new Bean3();
}
}
1.4.2 Bean的其他配置:
id和name的区别:
一般情况下,装配一个Bean时,通过指定一个id属性作为Bean的名称
id 属性在IoC容器中必须是唯一的
1,id遵守XML约束的id的约束.id约束保证这个属性的值是唯一的,而且必须以字母开始,可以使用字母、数字、连字符、下划线、句话、冒号, name没有这些要求
2,***** 如果bean标签上没有配置id,那么name可以作为id.
***** 如果Bean的名称中含有特殊字符,就需要使用name属性
例如:开发中Spring和Struts1整合的时候, /login.(早期开发中)
<bean name=”/login” class=””>
<bean name="#person" class="cn.itcast.bean.Person"/>
因为name属性可以相同,所以后出现Bean会覆盖之前出现的同名的Bean
现在的开发中都使用id属性即可.
类的作用范围:
scope属性 :
* singleton :单例的.(默认的值.)
单例,只初始化一次
* prototype :多例的.
多例,每获得一次就创建一个新的类
* request :web开发中.创建了一个对象,将这个对象存入request范围,request.setAttribute();
* session :web开发中.创建了一个对象,将这个对象存入session范围,session.setAttribute();
* globalSession :一般用于Porlet应用环境.指的是分布式开发(例如qq登录,其他子系统都能识别,不需要再次登录,如qq空间)(全局).不是porlet环境,globalSession等同于session;
实际开发中主要使用singleton,prototype
Bean的生命周期:
Spring初始化bean或销毁bean时,有时需要作一些处理工作,因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方法。
配置Bean的初始化和销毁的方法:
配置初始化和销毁的方法:
* init-method=”setup”
* destroy-method=”teardown”
执行销毁的时候,必须手动关闭工厂,而且只对 scope=”singleton”有效.(若为prototype,则n多个实例,销毁是不知销毁哪个)
<!-- <bean id="customer" class="cn.itcast.spring3.demo3.Customer" scope="prototype"/>
<bean id="product" class="cn.itcast.spring3.demo3.Product" init-method="setup" destroy-method="teardown">
<property name="name" value="空调"></property>
</bean> -->
@Test
// 测试初始化和销毁的方法
public void demo2(){
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml");
Product p1 = (Product) applicationContext.getBean("product");
System.out.println(p1);
applicationContext.close();
}
Bean的生命周期的11个步骤:
1.instantiate bean对象实例化(实例化类)
2.populate properties 封装属性(属性的注入)
3.如果Bean实现BeanNameAware 执行setBeanName(注入配置的类的名称)
4.如果Bean实现BeanFactoryAware 或者ApplicationContextAware 设置工厂setBeanFactory 或者上下文对象setApplicationContext(第四步:注入applicationContext"+applicationContext)
5.如果存在类实现BeanPostProcessor(后处理Bean),执行postProcessBeforeInitialization(初始化之前执行...)(可以在里面增强)
bean:实例对象
beanName:在配置文件中配置的类的标识.
6.如果Bean实现InitializingBean 执行afterPropertiesSet(属性设置后执行...)
7.调用<beaninit-method="init"> 指定初始化方法 init(调用手动设置的初始化方法...)
8.如果存在类实现BeanPostProcessor(处理Bean),执行postProcessAfterInitialization(第八步:初始化后执行...)(处理bean)
9.执行业务处理
10.如果Bean实现 DisposableBean 执行destroy(调用销毁的方法)
11.调用<beandestroy-method="customerDestroy"> 指定销毁方法 customerDestroy (手动配置的销毁方法)
<!-- <bean id="customerService" class="cn.itcast.spring3.demo4.CustomerServiceImpl" init-method="setup" destroy-method="teardown">
<property name="name" value="itcast"></property>
</bean>
<bean class="cn.itcast.spring3.demo4.MyBeanPostProcessor"></bean> -->(需要配置后处理bean,不用id,由Spring容器自动调用)
第五步,第八步只要有类创建就调用(可以做增强操作)
在CustomerService类的add方法之前进行权限校验?
public Object postProcessAfterInitialization(final Object bean, String beanName)
throws BeansException {
// 动态代理:(JDK动态代理必须对实现接口的类生成代理)
if(beanName.equals("customerService")){
Object proxy =
Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces() , new InvocationHandler() {
// 调用目标方法的时候,调用invoke方法.
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if("add".equals(method.getName())){
System.out.println("权限校验...");
Object result = method.invoke(bean, args);
//System.out.println(System.currentTimeMillis());
return result;
}
return method.invoke(bean, args);
}
});//(1,类加载器;2,类实现接口;3,类处理器)
return proxy;
}
return bean;
}
1.4.3 Bean中属性注入:
构造器注入:
<bean id="car"class="cn.itcast.spring3.demo5.Car">
<!-- <constructor-arg name="name" value="宝马"/>
<constructor-arg name="price" value="1000000"/> -->
<constructor-arg index="0" type="java.lang.String" value="奔驰"/>(第一个参数)(type:类型)
<constructor-arg index="1" type="java.lang.Double"value="2000000"/>
</bean>
public class Car {
private String name;
private Double price;
public Car() {
super();
}
public Car(String name, Double price) {
super();
this.name = name;
this.price = price;
}
@Override
public String toString() {
return "Car [name=" + name + ", price=" + price + "]";
}
}
setter方法注入1,普通属性:
<bean id="car2" class="cn.itcast.spring3.demo5.Car2">
<!-- <property>标签中name就是属性名称,value是普通属性的值,ref:引用其他的对象 -->
<property name="name" value="保时捷"/>(value:普通属性)
<property name="price" value="5000000"/>
</bean>
public class Car2 {
private String name;
private Double price;
public void setName(String name) {
this.name = name;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return "Car2 [name=" + name + ", price=" + price + "]";
}
}
setter方法注入2,对象属性:
<property name="car2" ref="car2"/>(ref:其他类的id或name)(使用<property>引入引用其他Bean)
<bean id="person" class="cn.itcast.spring3.demo5.Person">
<property name="name" value="Li"/>
<property name="car2" ref="car2"/>
</bean>
public class Person {
private String name;
private Car2 car2;
public void setName(String name) {
this.name = name;
}
public void setCar2(Car2 car2) {
this.car2 = car2;
}
@Override
public String toString() {
return "Person [name=" + name + ", car2=" + car2 + "]";
}
}
名称空间p:注入属性(1):
为了简化XML文件配置,Spring2.5版本引入了名称空间p.
p:<属性名>="xxx"引入常量值
p:<属性名>-ref="xxx"引用其它Bean对象
引入名称空间:
<beans xmlns="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">
<bean id="car2" class="cn.itcast.spring3.demo5.Car2" p:name="宝马"p:price="400000"/>
<bean id="person" class="cn.itcast.spring3.demo5.Person" p:name="LI"p:car2-ref="car2"/>
SpEL(spring expression language ):属性的注入(2):
Spring3.0提供注入属性方式:
语法:#{表达式}
#{'神回复:哈哈'}使用字符串
#{topicId3} 使用另一个bean
#{topicId4.content.toUpperCase()} 使用指定名属性,并使用方法
#{T(java.lang.Math).PI} 使用静态字段或方法
<bean id="" value="#{表达式}">
<bean id="car2" class="cn.itcast.spring3.demo5.Car2">
<property name="name" value="#{'大众'}"></property>
<property name="price" value="#{'120000'}"></property>
</bean>
<bean id="person"class="cn.itcast.spring3.demo5.Person">
<!--<property name="name" value="#{personInfo.name}"/>-->(某个对象的某个属性引用过来)(没get运行不了)
<property name="name"value="#{personInfo.showName()}"/>(调用其他类中的方法)
<property name="car2" value="#{car2}"/>
</bean>
<bean id="personInfo"class="cn.itcast.spring3.demo5.PersonInfo">
<property name="name" value="张三"/>
</bean>
1.4.4 集合属性的注入:
<bean id="collectionBean"class="cn.itcast.spring3.demo6.CollectionBean">
<!-- 注入List集合 -->
<value>LI</value>(普通值,对象:ref)
<!-- 注入set集合 -->
<value>HH</value>(普通值,对象:ref)
<!-- 注入map集合 -->
private Properties properties;
<property name="properties">(继承自HashTable(线程安全))
<props>
<prop key="username">root</prop>
<prop key="password">123</prop>
</props>
</property>
1.4.5 加载配置文件:
一种写法:可以在创建ApplicationContext对象时传入多个配置文件
ApplicationContext applicationContext = newClassPathXmlApplicationContext("bean1.xml",”bean2.xml”);(一次性传多个)
二种方法:可以在配置文件中通过<import>引入其他配置文件
<import resource="applicationContext2.xml"/>
<import resource="classpath:bean2.xml"/>
1.5 IOC装配Bean(注解方式)
1.5.1 Spring的注解装配Bean
Spring2.5 引入使用注解去定义Bean(使用注解可以没有set)
@Component 描述Spring框架中Bean
<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">
<context:component-scan base-package="cn.itcast.spring3"/>(扫描哪些包)
</beans>
Spring的框架中提供了与@Component注解等效的三个注解:
@Repository 用于对DAO实现类进行标注
@Service 用于对Service实现类进行标注
@Controller 用于对Controller实现类进行标注
*****这三个注解是为了让标注类本身的用途清晰(如:分层开发),Spring在后续版本会对其增强
1.5.2 Bean的属性注入:
普通属性;
@Value(value="itcast")
private String info;
对象属性:
@Autowired:自动装配默认使用类型注入.(一般都是按名称注入)
@Autowired注入时可以针对成员变量或者setter方法
@Autowired
@Qualifier("userDao") --- 按名称进行注入.
@Autowired
@Qualifier("userDao")
private UserDao userDao;
等价于
@Resource(name="userDao")
private UserDao userDao;
1.5.3 Bean其他的属性的配置:
配置Bean初始化方法和销毁方法:
* init-method 和destroy-method.
@PostConstruct 初始化
@PreDestroy 销毁
配置Bean的作用范围:
使用注解配置的Bean和<bean>配置的一样,默认作用范围都是singleton
@Scope注解用于指定Bean的作用范围
1.5.4 Spring3.0提供使用Java类定义Bean信息的方法
@Configuration//代表这个类就是配置类
public class BeanConfig{
@Bean(name="car")
public Car showCar(){
Car car = new Car();
car.setName("长安");
car.setPrice(40000d);
return car;
}
@Bean(name="product")
public Product initProduct(){
Product product = newProduct();
product.setName("空调");
product.setPrice(3000d);
return product;
}
}
采用手动方式加载@Configuration配置类
或者:<context:component-scan base-package="cn.itcast.spring3"/>(cn.itcast.spring3级以下的都可扫描)
1.5.5 实际开发中使用XML还是注解?
1,系统架构师选择什么
2,混合使用
XML:
* bean管理
注解;
* 注入属性的时候比较方便.(不需要提供set方法)(自动注入)
两种方式结合;一般使用XML注册Bean,使用注解进行属性的注入.
传统XML配置和注解配置混合使用
<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">
<context:annotation-config/>(使@Resource、@PostConstruct、@PreDestroy、@Autowired注解生效)
3,@Autowired
@Qualifier("orderDao")
private OrderDao orderDao;
4,运行测试类
多种装配Bean方式比较
1.6 Spring整合web开发:
正常整合Servlet和Spring没有问题的
但是每次执行Servlet的时候加载Spring配置,加载Spring环境.(加载一次就够了)
* 解决办法:在Servlet的init方法中加载Spring配置文件?(不可以)
* 当前这个Servlet可以使用,但是其他的Servlet的用不了了!!!
* 将加载的信息内容放到ServletContext中.ServletContext对象是全局的对象.服务器启动的时候创建的.在创建ServletContext的时候就加载Spring的环境.
* 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>
3,获得WebApplicationContext对象,(通过WebApplicationContext获得环境信息)
WebApplicationContext applicationContext=WebApplicationContextUtils.getWebApplicationContext(getServletContext());
WebApplicationContext applicationContext = (WebApplicationContext) getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
1.7 Spring集成JUnit测试:
1.程序中有Junit环境.
2.导入一个jar包.spring与junit整合jar包.
* spring-test-3.2.0.RELEASE.jar
3.测试代码:
<bean id="" value="#{表达式}">
<bean id="car2" class="cn.itcast.spring3.demo5.Car2">
<property name="name" value="#{'大众'}"></property>
<property name="price" value="#{'120000'}"></property>
</bean>
<bean id="person"class="cn.itcast.spring3.demo5.Person">
<!--<property name="name" value="#{personInfo.name}"/>-->(某个对象的某个属性引用过来)(没get运行不了)
<property name="name"value="#{personInfo.showName()}"/>(调用其他类中的方法)
<property name="car2" value="#{car2}"/>
</bean>
<bean id="personInfo"class="cn.itcast.spring3.demo5.PersonInfo">
<property name="name" value="张三"/>
</bean>
不用自己再加载文件