Spring笔记

风吹草地pp凉

于 2013-08-13 15:47:05 发布

阅读量598

点赞数

课程内容

1. 面向接口（抽象）编程的概念与好处

2. IOC/DI的概念与好处

a) inversion of control

b) dependency injection

3. AOP的概念与好处

5. Spring应用IOC/DI（重要）

a) xml

b) annotation

6. Spring应用AOP（重要）

a) xml

b) annotation

7. Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合（重要）

a) opensessionInviewfilter（记住，解决什么问题，怎么解决）

8. Spring JDBC

面向接口编程（面向抽象编程）

1. 场景：用户添加

2. Spring_0100_AbstractOrientedProgramming

a) 不是AOP:Aspect Oriented Programming

3. 好处：灵活

什么是IOC（DI），有什么好处

1. 把自己new的东西改为由容器提供

a) 初始化具体值

b) 装配

2. 好处：灵活装配

Spring简介

1. 项目名称：Spring_0200_IOC_Introduction

2. 环境搭建

a) 只用IOC

i. spring.jar , jarkata-commons/commons-loggin.jar

3. IOC容器

a) 实例化具体bean

b) 动态装配

4. AOP支持

a) 安全检查

b) 管理transaction

Spring IOC配置与应用

1. FAQ:不给提示：

a) window – preferences – myeclipse – xml – xml catalog

b) User Specified Entries – add

i. Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\spring-beans-2.5.xsd

ii. URI: file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resources/spring-beans-2.5.xsd

iii. Key Type: Schema Location

iv. Key: http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

2. 注入类型

a) Spring_0300_IOC_Injection_Type

b) setter（重要）

c) 构造方法（可以忘记）

d) 接口注入（可以忘记）

3. id vs. name：<bean name="hello" class="bean.Hello">这里可以用name也可以用id

a) Spring_0400_IOC_Id_Name

b) name可以用特殊字符

4. 简单属性的注入

a) Spring_0500_IOC_SimpleProperty

b) <property name=… value=….>

5. <bean 中的scope属性（有效范围）

a) Spring_0600_IOC_Bean_Scope

b) singleton 默认单例无论<property中ref调用这个bean多少次得到的都是同一个实例

c) proptotype 每次创建新的对象，action用这个

6. 集合注入：也就是<property是一个集合元素，比如List。

a) Spring_0700_IOC_Collections

b) 很少用，不重要！参考程序

贴一个文档里的例子：

<bean id="moreComplexObject" class="example.ComplexObject">
  <!-- results in a setAdminEmails(java.util.Properties) call -->
  <property name="adminEmails">
    <props>
        <prop key="administrator">administrator@example.org</prop>
        <prop key="support">support@example.org</prop>
        <prop key="development">development@example.org</prop>
    </props>
  </property>
  <!-- results in a setSomeList(java.util.List) call -->
  <property name="someList">
    <list>
        <value>a list element followed by a reference</value>
        <ref bean="myDataSource" />
    </list>
  </property>
  <!-- results in a setSomeMap(java.util.Map) call -->
  <property name="someMap">
    <map>
        <entry>
            <key>
                <value>an entry</value>
            </key>
            <value>just some string</value>
        </entry>
        <entry>
            <key>
                <value>a ref</value>
            </key>
            <ref bean="myDataSource" />
        </entry>
    </map>
  </property>
  <!-- results in a setSomeSet(java.util.Set) call -->
  <property name="someSet">
    <set>
        <value>just some string</value>
        <ref bean="myDataSource" />
    </set>
  </property>
</bean>

7. 自动装配重点

a) Spring_0800_IOC_AutoWire

b) byName：通过名字自动装配，如果<bean name="hello" class="bean.Hello" autowire="byName">指定了autowire="byName"（这个值默认是no），假设hello里有个属性是另一个bean，名字叫myBean，那么Spring会找xml的上下文里有没有叫myBean的bean，如果有则自动装配到hello里，找不到就不装配。

c) byType：不常用，通过类型自动装配，不过如果出现了多个相同的类型，会报错

d) 如果所有的bean都用同一种，可以使用beans的属性：default-autowire：xml开始的时候写一个default-autowire=xxx，然后每个bean都指定autowire="default"，这样bean里都会装配xxx

8. 生命周期

a) Spring_0900_IOC_Life_Cycle

b) lazy-init (不重要)：若lazy-init="true"在容器初始化的时候不初始化，直到getBean(这个bean);的时候它才初始化。比如我们的xml里有N多bean 这里可以用default lazy-init让他们都不初始化用什么加载什么

c) init-method destroy-methd 不要和prototype一起用（了解）：也就是指定初始化方法和destroy方法。

9. Annotation第一步：

a) 修改xml文件，参考文档<context:annotation-config />

10. @Autowired:把这个注解加到set方法之前

然后xml里：

<?xml version="1.0" encoding="GBK"?>
<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-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd"><!-- 上面增加了context的相关注解 详情看index.html#beans-annotation-config -->
	<context:annotation-config></context:annotation-config><!-- 加了这句之后会通过注解装配 -->
	<bean name="state" class="bean.Statement">
		<property name="statement" value="啦啦啦 "></property>
	</bean>
	<bean name="hello" class="bean.Hello">
	</bean>

</beans>

a) 默认按类型by type：上面就是发现state和需要的bean类型一样，所以进行了装配。

b) 如果想用byName，使用@Qulifier

@Autowired
	public void setUserDAO(@Qualifier("u") UserDAO userDAO) {
		this.userDAO = userDAO;
	}

c) 写在privat e field（第三种注入形式）（不建议，破坏封装）

d) 如果写在set上，@qualifier需要写在参数上

11. @Resource（重要）：就是把@Autowired改成@Resource

a) 加入：j2ee/common-annotations.jar

b) 默认是按名称找不到名称则按类型

c) 可以指定特定名称：用这个@Resource(name="xml里bean的名字")

d) 推荐使用

e) 不足：如果没有源码，就无法运用annotation，只能使用xml

12. @Component @Service @Controller @Repository:可以不在xml里配置bean，而是用@注解，看视频。默认component为类名首字母改成小写。这些注解目前都一样

a) 初始化的名字默认为类名首字母小写

b) 可以指定初始化bean的名字

13. @Scope:@Scope("prototype")每次都生成详见生命周期，默认是singleton

14. @PostConstruct = init-method; @PreDestroy = destroy-method;在初始化方法/销毁方法前加这个@即可

public class Hello {
	private Statement state = null;
	@PostConstruct	//初始化方法
	void init() {
		System.out.println("init");
	}
	public void sayHello(String name) {
		System.out.println("hello " + state.getStatement() + name );
	}

	public Statement getState() {
		return state;
	}
	@Resource(name="u")
	public void setState(Statement state) {
		this.state = state;
	}
	@PreDestroy	//销毁前方法
	void destory() {
		System.out.println("destory");
	}
	
}

什么是AOP

1. 面向切面编程Aspect-Oriented-Programming

a) 是对面向对象的思维方式的有力补充

2. Spring_1400_AOP_Introduction

3. 好处：可以动态的添加和删除在切面上的逻辑而不影响原来的执行代码

a) Filter

b) Struts2的interceptor

4. 概念：这些概念大概了解就行了

a) JoinPoint:连接点，比如@before，这就是一个连接点

b) PointCut也就是JoinPoint的集合，

c) Aspect（切面）：切面类的方法就是切面

d) Advice：@before @after等等

e) Target：被代理的对象

f) Weave：植入

Spring AOP配置与应用

1. 两种方式：

a) 使用Annotation

b) 使用xml

2. Annotation

a) 加上对应的xsd文件spring-aop.xsd，加入aspectjrt.jar aspectjweaver.jar两个包

b) beans.xml <aop:aspectj-autoproxy />:用注解的方式产生代理

c) 此时就可以解析对应的Annotation了

d) 建立我们的拦截类：比如身份验证之类的

e) 用@Aspect注解这个类

f) 建立处理方法

g) 用@Before来注解方法

h) 写明白切入点（execution …….）

i) 让spring对我们的拦截器类进行管理@Component

3. 常见的Annotation:

a) @Pointcut

b) @Before

c) @AfterReturning

d) @AfterThrowing

e) @After

f) @Around

4. 织入点语法

a) void !void

b) 参考文档（* ..）

5. xml配置AOP

a) 把interceptor对象初始化

b) <aop:config

i. <aop:aspect …..

1. <aop:pointcut

2. <aop:before

Spring整合Hibernate

1. Spring 指定datasource,需要引入jakarta-commons的commons-dbcp.jar

a) 参考文档，找dbcp.BasicDataSource

三种数据库连接池详情

i. c3p0

ii. dbcp

iii. proxool

b) 在DAO或者Service中注入dataSource

c) 在Spring中可以使用PropertyPlaceHolderConfigure来读取Properties文件的内容

2. Spring整合Hibernate

a) <bean .. AnnotationSessionFactoryBean>

i. <property dataSource

ii. <annotatedClasses

b) 引入hibernate 系列jar包

c) User上加Annotation

d) UserDAO或者UserServie 注入SessionFactory

e) jar包问题一个一个解决

3. 声明式的事务管理

a) 事务加在DAO层还是Service层？应该加载Service层，因为如果一个操作需要涉及多个DAO操作，而其中一个出现异常无法存入数据库，但另一个已经存入，则有逻辑错误

b) 使用annotation

i. 加入annotation.xsd

ii. 加入txManager bean：他会帮我们管理事物，自动begin commit close，好处：一旦出现异常，他会自动帮我们回滚

iii. <tx:annotation-driven

iv. 在需要事务的方法上加：@Transactional 他会自动在这个方法前后加上关于事物的业务逻辑begin commit close这些的

v. 需要注意，使用SessionFactory.getCurrentSession 不要使用OpenSession

c) @Transactional详解

注意下图的REQUIRED属性，如果有事务,那么加入事务,没有的话新建一个(required是默认的)

还有：

这些属性在TransactionDefinition 接口中定义，共有7种选项可用：

PROPAGATION_REQUIRED ：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS ：支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY ：支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW ：新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED ：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER ：以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED ：支持当前事务，如果当前事务存在，则执行一个嵌套事务（还不是太明白），如果当前没有事务，就新建一个事务。

Transactional其他属性

i. 什么时候rollback

1. 运行期异常，非运行期异常不会触发rollback

2. 必须uncheck (没有catch)

3. 不管什么异常，只要你catch了，spring就会放弃管理

4. 事务传播特性：propagation_required

5. read_only

d) xml（推荐，可以同时配置好多方法）

i. <bean txmanager

ii. <aop:config

1. <aop:pointcut

2. <aop:advisor pointcut-ref advice-ref

iii. <tx:advice: id transaction-manager =

e) HibernateTemplate、HibernateCallback、HibernateDaoSupport（不重要）介绍

i. 设计模式：Template Method

ii. Callback：回调/钩子函数

iii. 第一种：（建议）

1. 在spring中初始化HibernateTemplate，注入sessionFactory

2. DAO里注入HibernateTemplate

3. save写getHibernateTemplate.save();

iv. 第二种：

1. 从HibernateDaoSupport继承

2. 必须写在xml文件中，无法使用Annotation，因为set方法在父类中，而且是final的

f) spring整合hibernate的时候使用packagesToScan属性，可以让spring自动扫描对应包下面的实体类

Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2

1. 需要的jar包列表

jar包名称	所在位置	说明
antlr-2.7.6.jar	hibernate/lib/required	解析HQL
aspectjrt	spring/lib/aspectj	AOP
aspectjweaver	..	AOP
cglib-nodep-2.1_3.jar	spring/lib/cglib	代理，二进制增强
common-annotations.jar	spring/lib/j2ee	@Resource
commons-collections-3.1.jar	hibernate/lib/required	集合框架
commons-fileupload-1.2.1.jar	struts/lib	struts
commons-io-1.3.2	struts/lib	struts
commons-logging-1.1.1	单独下载，删除1.0.4(struts/lib)	struts spring
dom4j-1.6.1.jar	hibernate/required	解析xml
ejb3-persistence	hibernate-annotation/lib	@Entity
freemarker-2.3.13	struts/lib	struts
hibernate3.jar	hibernate
hibernate-annotations	hibernate-annotation/
hibernate-common-annotations	hibernate-annotation/lib
javassist-3.9.0.GA.jar	hiberante/lib/required	hibernate
jta-1.1.jar	..	hibernate transaction
junit4.5
mysql-
ognl-2.6.11.jar	struts/lib
slf4j-api-1.5.8.jar	hibernate/lib/required	hibernate-log
slf4j-nop-1.5.8.jar	hibernate/lib/required
spring.jar	spring/dist
struts2-core-2.1.6.jar	struts/lib
xwork-2.1.2.jar	struts/lib	struts2
commons-dbcp	spring/lib/jarkata-commons
commons-pool.jar	..
struts2-spring-plugin-2.1.6.jar	struts/lib

2. BestPractice：

a) 将这些所有的jar包保存到一个位置，使用的时候直接copy

3. 步骤

a) 加入jar包

b) 首先整合Spring + Hibernate

i. 建立对应的package

1. dao / dao.impl / model / service / service.impl/ test

ii. 建立对应的接口与类框架

1. S2SH_01

iii. 建立spring的配置文件（建议自己保留一份经常使用的配置文件，以后用到的时候直接copy改）

iv. 建立数据库

v. 加入Hibernate注解

1. 在实体类上加相应注解@Entity @Id等

2. 在beans配置文件配置对应的实体类，使之受管

vi. 写dao service的实现

vii. 加入Spring注解

1. 在对应Service及DAO实现中加入@Component，让spring对其初始化

2. 在Service上加入@Transactional或者使用xml方式（此处建议后者，因为更简单）

3. 在DAO中注入sessionFactory

4. 在Service中注入DAO

5. 写DAO与Service的实现

viii. 写测试

c) 整合Struts2

i. 结合点：Struts2的Action由Spring产生

ii. 步骤：

1. 修改web.xml加入 struts的filter

2. 再加入spring的listener，这样的话，webapp一旦启动，spring容器就初始化了

3. 规划struts的action和jsp展现

4. 加入struts.xml

a) 修改配置，由spring替代struts产生Action对象

5. 修改action配置

a) 把类名改为bean对象的名称，这个时候就可以使用首字母小写了

b) @Scope(“prototype”)不要忘记

iii. struts的读常量：

1. struts-default.xml

2. struts-plugin.xml

3. struts.xml

4. struts.properties

5. web.xml

iv. 中文问题：

1. Struts2.1.8已经修正，只需要改i18n.encoding = gbk

2. 使用spring的characterencoding

3. 需要严格注意filter的顺序

4. 需要加到Struts2的filter前面

v. LazyInitializationException

1. OpenSessionInViewFilter

2. 需要严格顺序问题

3. 需要加到struts2的filter前面

风吹草地pp凉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring笔记

课程内容1. 面向接口（抽象）编程的概念与好处2. IOC/DI的概念与好处a) inversion of controlb) dependency injection3. AOP的概念与好处4. Spring简介5. Spring应用IOC/DI（重要）a) xmlb) annotation6. Spring应用AOP（重要）a) xmlb) an
复制链接

扫一扫