spring 知识大纲

最新推荐文章于 2022-05-06 10:03:12 发布

易雪寒

最新推荐文章于 2022-05-06 10:03:12 发布

阅读量226

点赞数

分类专栏： Spring框架相关技术

原文链接：https://www.cnblogs.com/xiangjune/p/6599585.html

版权

Spring框架相关技术专栏收录该内容

23 篇文章 0 订阅

订阅专栏

课程内容

面向接口（抽象）编程的概念与好处
IOC/DI的概念与好处

a) inversion of control

b) dependency injection

AOP的概念与好处
Spring简介
Spring应用IOC/DI（重要）

a) xml

b) annotation

Spring应用AOP（重要）

a) xml

b) annotation

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

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

Spring JDBC
场景：用户添加
Spring_0100_AbstractOrientedProgramming

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

a) 不是AOP:Aspect Oriented Programming

好处：灵活
把自己new的东西改为由容器提供

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

a) 初始化具体值

b) 装配

好处：灵活装配
项目名称：Spring_0200_IOC_Introduction
环境搭建

Spring简介

a) 只用IOC

spring.jar , jarkata-commons/commons-loggin.jar
IOC容器

a) 实例化具体bean

b) 动态装配

AOP支持

a) 安全检查

b) 管理transaction

Spring IOC配置与应用

FAQ:不给提示：

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

b) User Specified Entries – add

Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\spring-beans-2.5.xsd
URI: file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resources/spring-beans-2.5.xsd
Key Type: Schema Location
Key: http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

2. 注入类型

c) Spring_0300_IOC_Injection_Type

d) setter（重要）

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

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

id vs. name

a) Spring_0400_IOC_Id_Name

b) Id\name都行

c) name可以用特殊字符

</bean>

<!--

-->

<constructor-arg>

</constructor-arg>

</bean>

简单属性的注入

a) Spring_0500_IOC_SimpleProperty

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

<bean 中的scope属性<bean 的生命范围>

Request\Session\GlobalSession只有Spring和Web Framework结合时才会起作用，比如Spring和Struts结合时才配，但是很少配、、、、

a) Spring_0600_IOC_Bean_Scope

b) singleton 单例（默认为Singleton）

在每个Sprign IOC容器中一个Bean定义对应一个对象实例

c) proptotype 每次创建新的对象

集合注入

a) Spring_0700_IOC_Collections

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

自动装配

a) Spring_0800_IOC_AutoWire

b) byName

<beans>

</bean>

</bean>

</bean>

</beans>

根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean,

并将其与属性自动装配。例如UserService里面有userDAO1属性，在装配时就会查找与userDAO1属性相同的Bean，即 <bean name="userDAO1" class="com.bjsxt.dao.impl.UserDAOImpl"> <propertyname="daoId" value="1"></property></bean>,所以当System.out.println(service.getUserDAO1)时，结果为daoId=1。

c)、byType

如果容器中存在一个与指定类型相同的bean,那么将与该属性自动装配。如果存在多个该类型的bean,那么将会抛出异常，并指出不能使用byType类型自动装配。

byType时，如果按照上面的形式写，将出错，因为userDAO1和userDAO2类型一样。

d）、constructor (了解)：与ByType方式类似，不同之处在于它应用于构造器参数，如果在容器中没有找到与构造器参数类型一致的bean,那么将抛出异常、、、

e) :autodetect（了解）：通过bean的自省机制来决定使用Constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式

d）、如果所有的bean都用同一种，可以使用beans的属性：default-autowire

生命周期

a) Spring_0900_IOC_Life_Cycle

b) lazy-init (不重要)

</bean>

如果不加 lazy-init=”true”，只要容器一初始化，也就是ClassPathXmlApplicationContext 一new出来，bean里面的所有class都会初始化、、加上之后如果Context初始化，class就不会初始化，而是用到时初始化、、、

c) init-method destroy-methd 不要和prototype一起用（了解）

Annotation第一步：

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

@Autowired

a) 默认按类型by type

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

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

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

@Resource（重要）

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

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

c) 可以指定特定名称

d) 推荐使用

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

@Component @Service @Controller @Repository

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

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

@Scope
@PostConstruct = init-method; @PreDestroy = destroy-method;

什么是AOP

面向切面编程Aspect-Oriented-Programming

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

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

a) Filter

b) Struts2的interceptor

概念：

a) JoinPoint 释意:切面与原方法交接点即切入点

b) PointCut 释意:切入点集合

c) Aspect（切面）释意:可理解为代理类前说明

d) Advice 释意:可理解为代理方法前说明例如@Before\@After加在切入点上的建议

e) Target 释意:被代理对象被织入对象

f) Weave 释意:织入

Spring AOP配置与应用

两种方式：

a) 使用Annotation

b) 使用xml

Annotation

a) 加上对应的xsd文件spring-aop.xsd

b) beans.xml <aop:aspectj-autoproxy />

需要在头部加 xmlns:aop="http://www.springframework.org/schema/aop"

以及xsi:schemaLocation="

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

还需要在Preferences --->xml Catalog引入spring-aop-2.5.xsd

(E:\Java Files\SpringJar\spring-framework-2.5.6\dist\resources)

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

d) 建立我们的拦截类

e) 用@Aspect注解这个类

@Aspect

@Component

public class LogInterceptor {

@Pointcut("execution(public * com.bjsxt.service..*.add(..))")

public void myMethod(){};

@Before("myMethod()")（在指定方法执行之前执行的方法）

public void before() {

System.out.println("method before");

}

@Around("myMethod()")

public void aroundMethod(ProceedingJoinPoint pjp) throws Throwable {

System.out.println("method around start");

pjp.proceed();

System.out.println("method around end");

}

f) 建立处理方法

g) 用@Before来注解方法

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

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

常见的Annotation:

a) @Pointcut 切入点声明以供其他方法使用 , 例子如下:

@Aspect

@Component

public class LogInterceptor {

@Pointcut("execution(public * com.bjsxt.dao..*.*(..))")

public void myMethod(){}

@Around("myMethod()")

public void before(ProceedingJoinPoint pjp) throws Throwable{

System.out.println("method before");

pjp.proceed();

}

@AfterReturning("myMethod()")

public void afterReturning() throws Throwable{

System.out.println("method afterReturning");

}

@After("myMethod()")

public void afterFinily() throws Throwable{

System.out.println("method end");

}

b) @Before 发放执行之前织入

c) @AfterReturning 方法正常执行完返回之后织入(无异常)

d) @AfterThrowing 方法抛出异常后织入

e) @After 类似异常的finally

f) @Around 环绕类似filter , 如需继续往下执行则需要像filter中执行FilterChain.doFilter(..)对象一样执行 ProceedingJoinPoint.proceed()方可,例子如下:

@Around("execution(* com.bjsxt.dao..*.*(..))")

public void before(ProceedingJoinPoint pjp) throws Throwable{

System.out.println("method start");

pjp.proceed();//类似FilterChain.doFilter(..)告诉jvm继续向下执行

}

织入点语法

a) void !void

b) 参考文档（* ..）

如果 execution(* com.bjsxt.dao..*.*(..))中声明的方法不是接口实现则无法使用AOP实现动态代理,此时可引入包” cglib-nodep-2.1_3.jar” 后有spring自动将普通类在jvm中编译为接口实现类,从而打到可正常使用AOP的目的.

xml配置AOP

a) 把interceptor对象初始化

b) <aop:config

<aop:aspect …..
1. <aop:pointcut
2. <aop:before

例子：

<aop:config>

<aop:aspect id="point" ref="logInterceptor">

<aop:pointcut

expression=

"execution(public * com.bjsxt.service..*.*(..))"

id="myMethod" />

<aop:before method="before" pointcut-ref="myMethod" />

<aop:around method="around" pointcut-ref="myMethod" />

<aop:after-returning method="afterReturning"

pointcut-ref="myMethod" />

<aop:after-throwing method="afterThrowing"

pointcut-ref="myMethod" />

<aop:after method="afterFinily"

pointcut="execution(public * om.bjsxt.service..*.*(..))" />

</aop:aspect>

</aop:config>

动态代理：Proxy和INvocationHandler的使用

Spring整合Hibernate

Spring 指定datasource

a) 参考文档，找dbcp.BasicDataSource

c3p0
Dbcp
Spring 里面的commons-dbcp.jar和commons-pool.jar

<value>classpath:com/foo/jdbc.properties</value>

</property>

</bean>

<bean id="dataSource" destroy-method="close"

class="org.apache.commons.dbcp.BasicDataSource">

</bean>

proxool

b) 在DAO或者Service中注入dataSource

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

Spring整合Hibernate

a) <bean .. AnnotationSessionFactoryBean>

<property dataSource
<annotatedClasses

<bean

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<value>classpath:jdbc.properties</value>

</property>

</bean>

<bean id="dataSource" destroy-method="close"

class="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName"

value="${jdbc.driverClassName}" />

</bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

<list>

<value>com.bjsxt.model.User</value>

<value>com.bjsxt.model.Log</value>

</list>

</property>

<props>

org.hibernate.dialect.MySQLDialect

</prop>

</props>

</property>

</bean>

b) 引入hibernate 系列jar包

c) User上加Annotation

d) UserDAO或者UserServie 注入SessionFactory

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

声明式的事务管理

a) 事务加在DAO层还是Service层？

b) annotation

加入annotation.xsd
加入txManager bean
<tx:annotation-driven>
<tx:annotation-driven transaction-manager="txManager"/>

须在Xml文件头里加上xsi:schemaLocation="

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd

例如: <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">

</property>

</bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

在需要事务的方法上加：@Transactional，会自动在前后加上关于事务的业务逻辑，开始时就是BeganTransaction(),结尾时是Transaction Commit().如果捕捉到任何的异常，就会自动Rollback(),如果是runTime异常，会自动回滚。。。
需要注意，Hibernate获得session时要使用SessionFactory.getCurrentSession 不能使用OpenSession

c) @Transactional详解

什么时候rollback
1. 运行期异常，非运行期异常不会触发rollback
2. 必须uncheck (没有catch)
3. 不管什么异常，只要你catch了，spring就会放弃管理
4. 事务传播特性：propagation_required

例如: @Transactional(propagation=Propagation.REQUIRED)等同于(@Transactional)

作用,一个方法声明了@Transactional事务后,其内再调用的方法不需要再声明@Transactional.

read_only

例如: @Transactional(propagation=Propagation.REQUIRED,readOnly=true)

当方法声明readOnly=true时,该方法及其调用的方法内都不执行insert update等

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

<bean txmanager
<aop:config
1. <aop:pointcut
2. <aop:advisor pointcut-ref advice-ref
3. <tx:advice: id transaction-manager =
4. <property name="packagesToScan"> 可定义扫描目标包下所有实体类

例如: <bean id="sessionFactory"

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.OracleDialect</prop>

</props>

</property>

<!--

<list>

<value>com.bjsxt.model.TestUser</value>

<value>com.bjsxt.model.Log</value>

</list>

</property>

-->

<list>

<value>com.bjsxt.model</value>

</list>

</property>

</bean>

<bean id="transactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

</property>

</bean>

<aop:config>

<aop:pointcut

expression="execution(public * com.bjsxt.service..*.*(..))"

id="myServiceMethod" />

<aop:advisor pointcut-ref="myServiceMethod" advice-ref="txAdvice"/>

</aop:config>

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="save*" propagation="REQUIRED" />

<tx:method name="add*" propagation="REQUIRED" />

<tx:method name="update*" propagation="REQUIRED" />

<tx:method name="del*" propagation="REQUIRED" />

<tx:method name="cancel*" propagation="REQUIRED" />

<tx:method name="*" read-only="true" />

</tx:attributes>

</tx:advice>

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

设计模式：Template Method(模板方法)
Callback：回调/钩子函数
第一种：（建议）
1. 在spring中初始化HibernateTemplate，注入sessionFactory

<bean id="hibernateTemplate"

class="org.springframework.orm.hibernate3.HibernateTemplate">

</bean>

DAO里注入HibernateTemplate

private HibernateTemplate hibernateTemplate;

@Resource

public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {

this.hibernateTemplate = hibernateTemplate;

}

save写getHibernateTemplate.save();

public void save(TestUser testUser) {

hibernateTemplate.save(testUser);

}

第二种：
1. 从HibernateDaoSupport继承(此方法不好用可忽略)
2. 必须写在xml文件中，无法使用Annotation，因为set方法在父类中，而且是final的

例如:

首先,新建SuperDAOImpl类(使用Annotation注入--@Component):

@Component

public class SuperDAOImpl {

private HibernateTemplate hibernateTemplate; //此处定义由spring注入管理

public HibernateTemplate getHibernateTemplate() {

return hibernateTemplate;

}

@Resource

public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {

this.hibernateTemplate = hibernateTemplate;

}

此时,xml中必须要有:

<bean id="hibernateTemplate"

class="org.springframework.orm.hibernate3.HibernateTemplate">

</bean>

或者,SuperDAOImpl类写成下面代码:

@Component

public class SuperDAOImpl extends HibernateDaoSupport {

@Resource(name="sessionFactory")

public void setSuperHibernateTemplate(SessionFactory sessionFactory) {

super.setSessionFactory(sessionFactory);

}

对应的xml中则可省略

<bean id="hibernateTemplate"………部分

只要包含

<bean id="sessionFactory"……..部分即可

最后,其他类继承SuperDaoImpl类后便可直接使用HibernateTemplate

@Component("u")

public class UserDAOImpl extends SuperDAOImpl implements UserDAO {

public void save(TestUser testUser) {

this.getHibernateTemplate().save(testUser);

}

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

Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2

需要的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

BestPractice：

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

步骤

a) 加入jar包

b) 首先整合Spring + Hibernate

建立对应的package
1. dao / dao.impl / model / service / service.impl/ test
2. 建立对应的接口与类框架
  1. S2SH_01
  2. 建立spring的配置文件（建议自己保留一份经常使用的配置文件，以后用到的时候直接copy改）
  3. 建立数据库
  4. 加入Hibernate注解
    1. 在实体类上加相应注解@Entity @Id等

在字段属性的get方法上加--@Column(name = "表字段名")

在beans配置文件配置对应的实体类，使之受管
写dao service的实现
加入Spring注解
1. 在对应Service及DAO实现中加入@Component，让spring对其初始化
2. 在Service上加入@Transactional或者使用xml方式（此处建议后者，因为更简单）
3. 在DAO中注入sessionFactory
4. 在Service中注入DAO
5. 写DAO与Service的实现
6. 写测试

c) 整合Struts2

结合点：Struts2的Action由Spring产生
步骤：
1. 修改web.xml加入 struts的filter

如下:

<filter-name>struts2</filter-name>

<filter-class>

org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter

</filter-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

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

如下:

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

<!--整个应用的参数服务启动时读取.

可指定spring初始化文件路径位置 -->

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

classpath*:spring/*applicationContext.xml

</param-value>

</context-param>

规划struts的action和jsp展现
加入struts.xml

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

修改action配置

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

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

struts的读常量：
1. struts-default.xml
2. struts-plugin.xml
3. struts.xml
4. struts.properties
5. web.xml
6. 中文问题：
  1. Struts2.1.8已经修正，只需要改i18n.encoding = gbk
  2. 使用spring的characterencoding

例:

<filter-name>CharacterEncodingFilter</filter-name>

<filter-class>

org.springframework.web.filter.CharacterEncodingFilter

</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>UTF-8</param-value>

</init-param>

<init-param>

<param-name>forceEncoding</param-name>

<param-value>true</param-value>

</init-param>

</filter>

需要严格注意filter的顺序
需要加到Struts2的filter前面
LazyInitializationException
1. OpenSessionInViewFilter
2. 需要严格顺序问题
3. 需要加到struts2的filter前面

附:

1．

@Autowired 与@Resource 都可以用来装配bean. 都可以写在属性定义上,或写在set方法上

@Autowired (srping提供的) 默认按类型装配

@Resource ( j2ee提供的 ) 默认按名称装配,当找不到(不写name属性)名称匹配的bean再按类型装配.

可以通过@Resource(name="beanName") 指定被注入的bean的名称, 要是指定了name属性, 就用字段名去做name属性值,一般不用写name属性.

@Resource(name="beanName")指定了name属性,按名称注入但没找到bean, 就不会再按类型装配了.

@Autowired 与@Resource可作用在属性定义上, 就不用写set方法了(此方法不提倡);

2．

Action类前加@Component,则Action可由spring来管理,例子如下:

Action中写:

@Component("u") //spring管理注解

@Scope("prototype") //多态

public class UserAction extends ActionSupport implements ModelDriven{

//内部属性需要有get/set方法且需要set方法前加@Resource或@Autowired

}

Struts2配置文件中写

Jsp中

Action中也可不加@Component，Action由struts2-spring-plugin管理。此时，如果Action中定义的属性有set方法则@Autowired 与@Resource也可不写，但是如果没有set方法，则需要在属性前加上@Autowired 或@Resource才能生效。

3．

Hibernate如果使用load来查询数据，例如：

Service中：

public User loadById(int id) {

return this.userDao.loadById(id);

}

DAO中：

public User loadById(int id) {

return (User)this.hibernateTemplate.load(User.class, id);

}

此时，session（应该说的是Hibernate的session）在事物结束（通常是service调用完）后自动关闭。由于使用的是load获取数据，在jsp页面申请取得数据时才真正的执行sql，而此时session已经关闭，故报错。

Session关闭解决方法：

在web.xml中增加filter—openSessionInView，用于延长session在jsp调用完后再关闭

如下所示：

注意：filter –openSessionInView 一定要在 filter—struts2之前调用

Filter顺序—先进后出！

<filter-name>OpenSessionInViewFilter</filter-name>

<filter-class>

org.springframework.orm.hibernate3.support.OpenSessionInViewFilter

</filter-class>

<init-param>

<param-name>sessionFactoryBeanName</param-name>

<param-value>sf</param-value>(此处默认指定的sessionFactory应为” sessionFactory” 默认可省略此行如果shring配置文件中配置的sessionFactory为”sf” 则此处需要写sf 一般用不到)

</init-param>

</filter>

<filter-mapping>

<filter-name> OpenSessionInViewFilter </filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<filter-name>struts2</filter-name>

<filter-class>

org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter

</filter-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

易雪寒

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
spring 知识大纲

课程内容面向接口（抽象）编程的概念与好处 IOC/DI的概念与好处a)inversion of controlb)dependency injectionAOP的概念与好处 Spring简介 Spring应用IOC/DI（重要）a)xmlb)annotationSpring应用AOP（重要）a)xmlb)annotationStruts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合（重要）a)opensessionInvi...
复制链接

扫一扫