Spring快速入门

----------------------- Page 1-----------------------

Spring

业务逻辑框架。(作用于三层)

1.Spring提出了三层架构的设计思想。

编写代码的时候需要符合的原则：

高低原则：高内聚、低耦合

开闭原则：对扩展开放、对修改关闭（不改变原有的代码添加新功能）

面向接口编程

使用Spring可以更好的帮助满足以上的原则。

3.提供很多的代码通用的支持（工具类、对很多技术都有通用支持）

Spring-IOC

Inversion of Control (IoC) 控制反转

dependency injection (DI) 依赖注入

使用SpringIOC容器:

1导入jar

----------------------- Page 2-----------------------

1 <dependency>

2 <groupId>org.springframework</groupId>

3 <artifactId>spring‐beans</artifactId>

4 <version>4.3.9.RELEASE</version>

5 </dependency>

6 <dependency>

7 <groupId>org.springframework</groupId>

8 <artifactId>spring‐context</artifactId>

9 <version>4.3.9.RELEASE</version>

10 </dependency>

11 <dependency>

12 <groupId>org.springframework</groupId>

13 <artifactId>spring‐context‐support</artifactId>

14 <version>4.3.9.RELEASE</version>

15 </dependency>

16 <dependency>

17 <groupId>org.springframework</groupId>

18 <artifactId>spring‐core</artifactId>

19 <version>4.3.9.RELEASE</version>

20 </dependency>

21 <dependency>

22 <groupId>org.springframework</groupId>

23 <artifactId>spring‐expression</artifactId>

24 <version>4.3.9.RELEASE</version>

25 </dependency>

26 <dependency>

27 <groupId>org.springframework</groupId>

28 <artifactId>spring‐instrument</artifactId>

29 <version>4.3.9.RELEASE</version>

30 </dependency>

2.配置配置文件

1 applicationContext.xml

2 <bean id="bean的名称" class="对象的类型"/>

3.加载IOC容器

1 ApplicationContext ac = new ClassPathXmlApplicationContext(

2 "classpath:ioc/ioc01/applicationContext.xml");

3 ac.getBean("bean名称") //获取IOC容器中管理的对象

IOC容器

IOC是一个存放对象（bean）容器,进行控制反转（原来创建对象的过程是由类自己控制，创建对象的过程交个

IOC容器，控制权反转）,用于代码的解耦和，增加代码的可维护性。

IOC容器知识点

1.IOC容器的类型

----------------------- Page 3-----------------------

BeanFactory(IOC核心)

实现类:XmlBeanFactory

使用该实现类需要传递一个参数（Resource,可以理解为File封装,File的路径比较繁琐）

Resource:

ClassPathResource 表示资源在classpath下

FileSystemResource 表示资源在文件系统中

UrlResource 表示资源在网络上

ByteArrayResource 表示资源内存中

InputStreamResource 表示资源在流中

ApplicationContext

实现：

ClassPathXmlApplicationContext

表示容器配置文件在classpath下

1 //建议使用方式

2 ApplicationContext ac = new

ClassPathXmlApplicationContext("classpath:ioc/ioc02/applicationContext.xml");

FileSystemXmlApplicationContext

表示容器配置文件在文件系统中

1 //建议使用方式

2 ApplicationContext ac = new

FileSystemXmlApplicationContext("file:E:/applicationContext.xml");

2.IOC容器帮助我们完成工作

1.实例化

2.装配（注入）

1.装配(基于getter和setter方法)

a.简单值装配

基本类型（8）以及其包装类：byte short int long ﬂoat double char boolean

String 、Class、Resource

1 <bean id="springBean" class="com.itany.spring_ioc.ioc03.SpringBean">

2 <property name="age" value="18"></property>

3 <property name="bytes" value="127"></property>

4 <property name="sex" value="m"></property>

5 <property name="name" value="admin"></property>

6 <property name="clazz">

7 <value>java.lang.String</value>

8 </property>

9 </bean>

b.其他的bean引用

----------------------- Page 4-----------------------

1 <bean id="springBean" class="com.itany.spring_ioc.ioc04.SpringBean">

2 <property name="otherBean" ref="ob"></property>

3 <property name="otherBean1">

4 <ref bean="otherBean1" />

5 </property>

6 </bean>

c.集合类型

Array(数组)

1 <!‐‐数组类型为简单值‐‐>

2 <list>

3 <value>简单值</value>

4 </list>

5 <!‐‐数组类型为其他bean的引用‐‐>

6 <list>

7 <ref bean="其他beanID"/>

8 <bean class="其他bean的类型"></bean><!‐‐匿名bean‐‐>

9 </list>

List

1 <!‐‐List类型为简单值‐‐>

2 <list>

3 <value>简单值</value>

4 </list>

5 <!‐‐List类型为其他bean的引用‐‐>

6 <list>

7 <ref bean="其他beanID"/>

8 <bean class="其他bean的类型"></bean><!‐‐匿名bean‐‐>

9 </list>

Set

1 <!‐‐Set类型为简单值‐‐>

2 <set>

3 <value>简单值</value>

4 </set>

5 <!‐‐Set类型为其他bean的引用‐‐>

6 <set>

7 <ref bean="其他beanID"/>

8 <bean class="其他bean的类型"></bean><!‐‐匿名bean‐‐>

9 </set>

Map

----------------------- Page 5-----------------------

1 <!‐‐map key和value都是简单值‐‐>

2 <map>

3 <entry key="简单值" value="简单值"></entry>

4 <entry>

5 <key>

6 <value>简单值</value>

7 </key>

8 <value>简单值</value>

9 </entry>

10 </map>

12 <!‐‐map key和value都是其他bean的引用‐‐>

13 <map>

14 <entry key‐ref="其他bean的ID" value‐ref="其他bean的ID"></entry>

15 <entry>

16 <key>

17 <ref bean="其他bean的ID"/>

18 </key>

19 <ref bean="其他bean的ID"/>

20 </entry>

21 </map>

Properties

1 <props>

2 <prop key="key值">value值</prop>

3 </props>

d.null的装配

1 <property name="name">

2 <null/>

3 </property>

e.使用p命名空间进行装配(只能对简单值和其他bean的引用)

1 1.给配置文件的头部添加

2 xmlns:p="http://www.springframework.org/schema/p"

4 简单值

5 <bean id="springBean1" class="com.itany.spring_ioc.ioc03.SpringBean"

6 p:age="18" p:bytes="127" p:sex="m" p:name="admin" p:clazz="java.lang.String">

</bean>

9 其他bean引用

10 <bean id="springBean1" class="com.itany.spring_ioc.ioc04.SpringBean"

11 p:otherBean‐ref="ob" p:otherBean1‐ref="otherBean1">

12 </bean>

2.实例化

----------------------- Page 6-----------------------

IOC容器中Bean的生命周期

静态代码块-->实例化-->装配(setter方法)-->[init]-->使用 -->[destory]-->从容器中移除

1 销毁容器

2 1.所有的方法都是在子类中。

4 2.方法含有两种：

5 ac.destory() ‐‐‐>立即销毁容器

6 ac.registerShutdownHook(); ‐‐>代码正常结束后销毁容器

在代码获取文件资源:

1 Test07.class.getResourceAsStream("/") ‐‐‐>获取的为classPath目录

2 Test07.class.getResourceAsStream("") ‐‐‐>获取的为当前这个类（Test07）所在的目录

3 Test07.class.getClassLoader().getResourceAsStream("")‐‐>获取的为classPath目录

3.实例化方式

a.构造方法

无参数

1 <bean id="" class=""/>

有参数

1 <bean id="" class="">

2 <constructor‐arg index="参数的顺序" type="参数的类型">

3 <value>简单值</value>

4 <ref bean="其他bean的id"/>

5 </constructor‐arg>

6 </bean>

b.静态工厂

无参数

1 <bean id="" class="工厂类" factory‐method="工厂方法"/>

有参数

1 <bean id="" class="工厂类" factory‐method="工厂方法">

2 <constructor‐arg index="参数的顺序" type="参数的类型">

3 <value>简单值</value>

4 <ref bean="其他bean的id"/>

5 </constructor‐arg>

6 </bean>

c.实例工厂(通常情况至少含有两个bean)

----------------------- Page 7-----------------------

无参数

1 <bean id="" factory‐bean="工厂bean" factory‐method="工厂方法"/>

有参数

1 <bean id="" factory‐bean="工厂bean" factory‐method="工厂方法">

2 <constructor‐arg index="参数的顺序" type="参数的类型">

3 <value>简单值</value>

4 <ref bean="其他bean的id"/>

5 </constructor‐arg>

6 </bean>

4.实例化的时机

IOC容器在什么时间点帮助我们常见对象。

BeanFactory:懒实例化Bean(创建IOC容器的时候不会对其中的Bean实例化，使用Bean对象的时候才会实

例化)

ApplicationContext:默认即时实例化（创建IOC就会实例所有的Bean）

可以对其修改为懒初始化:

1 <bean lazy‐init="true"/> ‐‐‐>对于当前这个bean为懒实例化

3 在IOC配置文件的头部添加 default‐lazy‐init="true" 表示当前IOC容器中的所有的bean都是懒实例化

5.bean的域

在IOC容器中Bean默认都为单例.

bean中的属性为线程不安全的。

1 <bean scope="prototype"/> ‐‐>将该bean变为多例

3 如果将Bean变为多例，那么这个bean中配置了destory‐method的话，也不会调用

6.Resource

它就是一个File的封装.

它的实现含有:

ClassPathResource 表示资源在classpath下

FileSystemResource 表示资源在文件系统中

UrlResource 表示资源在网络上

ByteArrayResource 表示资源内存中

InputStreamResource 表示资源在流中

Resource获取方式

1.直接new实现类

2.可以通过ac.getResource("")

----------------------- Page 8-----------------------

1 ac.getResource("classpath:hibernate.cfg.xml");

2 ac.getResource("file:E:/Wildlife.wmv");

Resource类型的属性装配(简单值装配)

1 <property name="resource" value="classpath:dataSource.properties"></property>

3 <property name="resource" value="file:E:\Wildlife.wmv"></property>

7.继承配置

如果两个以上类存在相同的属性，如果在装配的时候属性值也是装配一致，这个时候就可以使用继承配置.

1 <!‐‐将相同的配置拿到一个bean中，需要将该bean配置abstract="true"(表示这个bean不会进行实例化)

‐‐>

2 <bean id="parentBean" abstract="true">

3 <property name="name" value="admin"></property>

4 </bean>

6 <!‐‐子bean对父bean进行引用采用parent属性‐‐>

7 <bean id="springBean" class="com.itany.spring_ioc.ioc17.SpringBean"

8 parent="parentBean">

9 <property name="pwd" value="123"></property>

10 </bean>

8. 自动装配(针对其他bean的引用)

对于其他bean引用如果不想配置，可以使用自动装配

1 <!‐‐

2 在bean中添加一个属性 autowire (默认default no)

3 byName

4 1.对set方法的名称在IOC容器中需要存在一个bean的名称与之相同

5 2.存在这个bean类型必须和set方法参数的类型一致

6 byType

7 1.set方法参数的类型需要在IOC容器中存在Bean

8 2.存在的bean有且只能含有一个

9 constructor

10 1.需要一个包含自动装配属性的构造函数。

11 2.这种装配方式和set方法没有任何关系，只和构造函数有关系

12 3.采用ByName和ByType同时装配

13 byName:Name是构造方法参数的名称

14 byType:Tyoe是构造方法参数的类型

15 ‐‐>

16 <bean autowire=""/>

9.FactoryBean

编写代码创建对象，比配置IOC更加简单，但是我们又想编写代码创建对象，将该交个IOC容器管理，就可以使

用FactoryBean。

----------------------- Page 9-----------------------

1.实现接口FactoryBean

public SessionFactory getObject() 表示生成的对象过程

public Class<?> getObjectType() 表示生成对象的类型（为了保证兼容性存在，现在没有作

用）

public boolean isSingleton() 表示生成对象是否为单例

2.将这个FacrotyBean配置到IOC容器中。

10.IOC容器中后处理器

[beanFacory后处理器]-->静态代码块-->实例化-->装配(setter方法)-->

[beforeInit]--->[init]---[afterInit]-->使用 -->[destory]-->从容器中移除

1.Bean的后处理器--BeanPostProcessor

1.后处理器的两个方法分别在初始化方法之前和初始化方法之后（初始化方法可以不存在）

2.后处理是对所有IOC容器中bean有效

1.实现接口BeanPostProcessor

2.将这个后处理器添加到ioc容器

2.BeanFactory后处理--BeanFactoryPostProcessor

1.后处理器的在静态代码块之前调用

2.后处理是对所有IOC容器中bean有效

1.实现接口BeanFactoryPostProcessor

2.将这个后处理器添加到ioc容器

11.从Bean中获取容器

1.使用Bean让其实现接口ApplicationContextAware （BeanFctoryAware）

2.将这个配置到Ioc容器.

12.读取配置文件

1 <bean

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

3 <property name="location" value="classpath:dataSource.properties"></property>

4 </bean>

13. 自定义转换器注册

----------------------- Page 10-----------------------

1 <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">

2 <property name="customEditors">

3 <map>

4 <entry key="java.util.Date"

value="com.itany.spring_ioc.ioc24.editors.DateEditor"></entry>

5 </map>

6 </property>

7 </bean>

Spring-AOP

AOP(Aspect-Oriented Programming)面向切面编程.

定义：将交叉业务逻辑(基本功能相似，交织在代码各个角落)抽取出来变为切面，由不同AOP实现进行在适当

的时机（编译期、运行期(常用)）添加到适当的位置(切点)。

AOP的术语

切面 Ascpect: 交叉业务逻辑抽象出的业务接口。

通知 Advice: 切面的代码实现。(代码中需要真正实现)

连接点 J oinPoint: 切面的位置（接口）

切点 PointCut: 真正位置实现，连接点的实现（代码中需要实现的）

代理 Porxy : aop的原理（动态代理）

目标对象,代理对象 Target : 通知添加类

织入: Weaving : 将通知添加到切点过程--织入过程

引入: Intruduction: 给类添加功能。对类引入新的方法

Spring-AOP

定义：将交叉业务逻辑(基本功能相似，交织在代码各个角落)抽取出来变为切面，Spring-AOP实现进行在

运行期,添加到切点的位置。

使用AOP的好处

1.将交叉业务逻辑和功能业务进行分离（解耦和）。

2.只要要进行分离之后，代码就模块化了

1.方便维护。

2.不改变原有的代码的情况下动态添加新的功能（开闭原则）。

3.方便项目中的任务分配。

AOP的原理:代理模式

静态代理

动态代理（AOP的原理）

Spring默认采用的为J DK的动态代理，如果没有目标类没有接口，采用就为cglib技术.

Spring-AOP(2.x--后处理器)

添加依赖

----------------------- Page 11-----------------------

1 <dependency>

2 <groupId>org.springframework</groupId>

3 <artifactId>spring‐aop</artifactId>

4 <version>${spring.version}</version>

5 </dependency>

6 <dependency>

7 <groupId>org.springframework</groupId>

8 <artifactId>spring‐aspects</artifactId>

9 <version>${spring.version}</version>

10 </dependency>

11 <dependency>

12 <groupId>cglib</groupId>

13 <artifactId>cglib</artifactId>

14 <version>3.2.5</version>

15 </dependency>

1.编写通知

[2.编写切点(AspectJ表达式) 不需要编写]

3.织入

编写通知(就是一个普通类)

前置通知

表示给方法前添加功能。

1 //第一种写法

2 public void methodName(){}

4 //第二种写法

5 public void methodName(JoinPoint joinPoint){}

配置:

1 <aop:config>

2 <aop:pointcut expression="AspectJ表达式" id="pc"/>

3 <aop:aspect ref="通知的ID">

4 <aop:before method="前置通知的方法名称" pointcut‐ref="pc"/>

5 </aop:aspect>

6 </aop:config>

后置通知

表示方法正常结束后添加功能。

----------------------- Page 12-----------------------

1 //第一种写法

2 public void methodName(){}

4 //第二种写法

5 public void methodName(JoinPoint joinPoint){}

7 //第三种写法

8 public void methodName(JoinPoint joinPoint,Object returnVal){}

配置

1 <aop:config>

2 <aop:pointcut expression="AspectJ表达式" id="pc"/>

3 <aop:aspect ref="通知的ID">

4 <!‐‐前两种方法的配置方式‐‐>

5 <aop:after‐returning method="后置通知的方法名称" pointcut‐ref="pc"/>

6 <!‐‐第三种方法的配置方式‐‐>

7 <aop:after‐returning method="后置通知的方法名称" pointcut‐ref="pc" returning="返回值

变量名称"/>

8 </aop:aspect>

9 </aop:config>

异常通知

表示方法异常结束之后添加功能。

1 //第一种写法

2 public void methodName(){}

4 //第二种写法

5 public void methodName(JoinPoint joinPoint){}

7 //第三种写法

8 public void methodName(JoinPoint joinPoint,Exception ex){}

配置

1 <aop:config>

2 <aop:pointcut expression="AspectJ表达式" id="pc"/>

3 <aop:aspect ref="通知的ID">

4 <!‐‐前两种方法的配置方式‐‐>

5 <aop:after‐throwing method="异常通知的方法名称" pointcut‐ref="pc"/>

6 <!‐‐第三种方法的配置方式‐‐>

7 <aop:after‐throwing method="异常通知的方法名称" pointcut‐ref="pc" throwing="异常变量

名称"/>

8 </aop:aspect>

9 </aop:config>

环绕通知

表示给方法的前和方法后添加功能。

----------------------- Page 13-----------------------

编写环绕通知方法需要三个条件(在环绕通知，业务由用户自己调用)

1 /**

2 * 1.需要Object类型的返回值

3 * 2.需要含有一个参数 ProceedingJoinPoint

4 * 3.需要抛出Throwable的异常

5 **/

6 public Object methodName(ProceedingJoinPoint joinPoint) throws Throwable{}

配置

1 <aop:config>

2 <aop:pointcut expression="AspectJ表达式" id="pc"/>

3 <aop:aspect ref="通知的ID">

4 <aop:around method="环绕通知的方法名称" pointcut‐ref="pc"/>

5 </aop:aspect>

6 </aop:config>

织入

创建IOC容器(需要引入aop命名空间)

1.配置目标类的bean

2.配置通知bean

3.织入

AspectJ表达式

1 1.within(包名.类名) ‐‐‐‐>表示给这个类中的所有的方法添加功能

2 2.execution(方法) ‐‐‐>表示给该批方法添加功能

3 execution(java.lang.String logout(java.lang.String)) 拦截IOC容器中所有的

Bean，只要bean中存在execution里面的方法前面，就会添加通知.

4 execution(void login(java.lang.String,java.lang.String))

5 execution(* log*(..))

6 1.(*)‐‐‐>任意类型的返回值，任意多个字符

7 2.(..)‐‐>任意类型的参数

8 execution(* log*(..,java.lang.String))

execution(*com.itany.spring_aop.aop02.service.impl.UserServiceImpl.login(..))

9 execution(* com.itany.spring_aop.aop04.service.impl.*ServiceImpl.*(..))

10 3.还可以使用not and or

11 execution(void login(java.lang.String,java.lang.String)) or execution(java.lang.String

logout(java.lang.String))

12 4.注解

13 @annotation(注解类型)

14 1.自定义注解(空注解)(com.itany.spring_aop.aop04.annotation.Timer)

15 2.@annotation(com.itany.spring_aop.aop04.annotation.Timer)

Spring注解

ioc中的注解

前提条件：扫描包(需要context命名空间)

----------------------- Page 14-----------------------

将一个类对象添加IOC容器中

@Component

@Controller 如果类为Action层

@Service 如果类为Service层

@Repository 如果类为Dao层

默认会给bean设置一个名称：类名首字母小写

可以覆盖@Component(value "bean的名称")

装配

简单值装配:

@Value("值")

其他bean的引用

1 //1.spring实现

2 @Autowired ‐‐‐>根据byName和byType通知装配

3 如果装配不上结合 @Qualifier （value="指定的bean的id"）用户自定义装配的bean

5 //2.官方标准

6 @javax.annotation.Resource(name="ob")

8 //3.jsr330标准

9 需要引入标准依赖

10 <dependency>

11 <groupId>javax.inject</groupId>

12 <artifactId>javax.inject</artifactId>

13 <version>1</version>

14 </dependency>

17 @Inject ==>@Autowired

18 @Named(value="ob") ==> @Qualifier

集合类型装配

需要结合命名空间(util)

需要注解

@javax.annotation.Resource(name "资源名称")

资源配置：使用util命名空间

1 <util:list id="ints">

2 <value>1</value>

3 <value>2</value>

4 </util:list>

初始化和销毁方法

----------------------- Page 15-----------------------

@PostConstruct

@PreDestory

bean的域

@Scope(value "prototype") -->类级别

aop 中的注解

1.将目标类添加到IOC容器（@Service）

2.给通知添加到IOC容器(@Componet)

3.配置切面给通知添加@Aspect

4.配置pointcut 在通知中添加空方法,在该方法上添加@Pointcut("AspectJ表达式")

5.方法上配置通知类型

1.前置通知@Before("pointcut()")‐‐‐>pointcut方法名的（）不能丢

2.后置通知@AfterRetuning(pointcut="",retuning="")

3.异常通知@AfterThrowing(pointcut="",throwing="")

4.环绕通知@Around("pointcut()")

6.配置解析AspectJ注解的后处理器

方式一:在IOC容器中添加

<bean

class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"></bean>

方式二：（需要aop命名空间）在ioc容器中添加

<aop:aspectj‐autoproxy />

spring整合

spring和web的整合

核心思想：将IOC的初始化过程给WEB容器。

1.添加依赖

1 <dependency>

2 <groupId>org.springframework</groupId>

3 <artifactId>spring‐web</artifactId>

4 <version>${spring.version}</version>

5 </dependency>

2.配置 web.xml

----------------------- Page 16-----------------------

1

2 <!‐‐ 用户自定义配置文件 ‐‐>

3 <context‐param>

4 <param‐name>contextConfigLocation</param‐name>

5 <param‐value>classpath:applicationContext‐*.xml</param‐value>

6 </context‐param>

9 <!‐‐ 在启动tomcat时候初始化IOC容器默认加载为/WEB‐INF/applicationContext.xml ‐‐>

10 <listener>

11 <listener‐class>org.springframework.web.context.ContextLoaderListener</listener‐

class>

12 </listener>

3.注入过程

dao--->service--->controller

spring和jdbc的整合

1.添加依赖

1 <dependency>

2 <groupId>org.springframework</groupId>

3 <artifactId>spring‐jdbc</artifactId>

4 <version>${spring.version}</version>

5 </dependency>

7 <!‐‐ 事务配置 ‐‐>

8 <dependency>

9 <groupId>org.springframework</groupId>

10 <artifactId>spring‐tx</artifactId>

11 <version>${spring.version}</version>

12 </dependency>

13 <!‐‐数据库驱动‐‐>

14 <dependency>

15 <groupId>mysql</groupId>

16 <artifactId>mysql‐connector‐java</artifactId>

17 <version>#{mysql‐driver.version}</version>

18 </dependency>

2.配置

1.配置dataSource （两种）

a.使用第三方的数据源

1.spring数据源的用法

----------------------- Page 17-----------------------

1 <!‐‐使用spring提供数据源‐‐>

2 <!‐‐ 使用spring提供的数据源不提供连接池 ‐‐>

3 <bean id="dataSource"

4 class="org.springframework.jdbc.datasource.DriverManagerDataSource">

5 <property name="driverClassName" value="${mysql.driver}"></property>

6 <property name="url" value="${mysql.url}"></property>

7 <property name="username" value="${mysql.username}"></property>

8 <property name="password" value="${mysql.password}"></property>

9 </bean>

11 <!‐‐ 工作中常用的一些数据源 dbcp c3p0 druid(德鲁伊)... ‐‐>

2.dbcp的用法

1 <!‐‐添加依赖‐‐>

2 <dependency>

3 <groupId>org.apache.commons</groupId>

4 <artifactId>commons‐dbcp2</artifactId>

5 <version>2.1.1</version>

6 </dependency>

1 <!‐‐ 使用dbcp2 ‐‐>

2 <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">

3 <property name="driverClassName" value="${mysql.driver}"></property>

4 <property name="url" value="${mysql.url}"></property>

5 <property name="username" value="${mysql.username}"></property>

6 <property name="password" value="${mysql.password}"></property>

8 <!‐‐ 连接池的配置 ‐‐>

9 <property name="initialSize" value="${dbcp.initialSize}"></property>

10 <property name="maxTotal" value="${dbcp.maxTotal}"></property>

11 <property name="maxIdle" value="${dbcp.maxIdle}"></property>

12 <property name="minIdle" value="${dbcp.minIdle}"></property>

13 <property name="maxWaitMillis" value="${dbcp.maxWaitMillis}"></property>

14 </bean>

3.druid数据源

1 <dependency>

2 <groupId>com.alibaba</groupId>

3 <artifactId>druid</artifactId>

4 <version>1.1.3</version>

5 </dependency>

----------------------- Page 18-----------------------

1 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

2 <property name="driverClassName" value="${mysql.driver}"></property>

3 <property name="url" value="${mysql.url}"></property>

4 <property name="username" value="${mysql.username}"></property>

5 <property name="password" value="${mysql.password}"></property>

7 <property name="initialSize" value="${dbcp.initialSize}"></property>

8 <property name="maxActive" value="${dbcp.maxTotal}"></property>

9 <property name="maxWait" value="${dbcp.maxWaitMillis}"></property>

10 <property name="minIdle" value="${dbcp.minIdle}"></property>

11 </bean>

b.j ndi配置方式(将数据源交给web容器管理)

1.进入tomcat 目录conf （context.xml）

1 <Resource name="user/dataSource" auth="Container"

2 type="javax.sql.DataSource"

3 factory="org.apache.commons.dbcp2.BasicDataSourceFactory"

4 driverClassName="com.mysql.jdbc.Driver"

5 url="jdbc:mysql://127.0.0.1:3306/spring"

6 username ="root" />

2.在web程序中引用(web.xml)

1 <resource‐ref>

2 <res‐ref‐name>user/dataSource</res‐ref‐name>

3 <res‐auth>Container</res‐auth>

4 <res‐type>javax.sql.DataSource</res‐type>

5 </resource‐ref>

3.spring中使用j ndi （ioc容器的配置文件）

1 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">

2 <property name="jndiName" value="java:comp/env/user/dataSource"></property>

3 </bean>

5 <!‐‐或者使用‐‐>

6 <jee:jndi‐lookup id="dataSource" jndi‐name="java:comp/env/user/dataSource"></jee:jndi‐

lookup>

3,注入过程

dataSource-->jdbcTemplate-->dao--->service--->controller

事务配置

事务的属性(五种)

1.传播属性(Propagation) 事务的边界

REQUIRED 添加事务，如果没有事务事务创建新的事务 (新增、删除、修改)

SUPPORTS 不会添加事务，如果存在事务也可以执行(查询)

----------------------- Page 19-----------------------

2.隔离属性(isolation)

READ_COMMITTED 不会发生脏读，但是可以发生幻读和不可重复读

READ_UNCOMMITTED 脏读、幻读、不可重复读都可以发生

REPEATABLE_READ 不会发生脏读,不可重复但是可以发生幻读(mysql和oracle不支持)

SERIALIZABLE 不会发生脏读,不可重复、幻读

3.回滚条件

默认抛出RuntimeException

4.只读优化

read-only

5.超时处理

timeout

1 <!‐‐事务管理器‐‐>

2 <bean id="transactionManager"

3 class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

4 <property name="dataSource" ref="dataSource"></property>

5 </bean>

7 <!‐‐spring1.x版本的环绕通知 TransactionInterceptor‐‐>

8 <tx:advice id="transactionAdvice" transaction‐manager="transactionManager">

9 <tx:attributes>

10 <tx:method name="login" propagation="REQUIRED" isolation="DEFAULT" rollback‐

for="java.lang.Exception" read‐only="true" timeout="‐1"/>

11 <tx:method name="regist" propagation="REQUIRED"/>

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

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

14 </tx:attributes>

15 </tx:advice>

17 <!‐‐织入‐‐>

18 <aop:config>

19 <aop:pointcut expression="execution(* org.itany.service.impl.*ServiceImpl.*(..))"

id="pc"/>

20 <aop:advisor advice‐ref="transactionAdvice" pointcut‐ref="pc"/>

21 </aop:config>

使用注解配置事务

1 <!‐‐事务管理器‐‐>

2 <bean id="transactionManager"

3 class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

4 <property name="dataSource" ref="dataSource"></property>

5 </bean>

6 <!‐‐事务的注解驱动‐‐>

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

9 <!‐‐添加注解‐‐>

10 在需要添加事务方法上添加@Transactional(propagation=Propagation.REQUIRED)

----------------------- Page 20-----------------------

事务的并发会发生的一些错误：

脏读: 一个事务读取到另一个事务没有提交的数据。（mysql和oracle不会发生）

不可重复读: 读取的数据和数据库不一致（一个事务在读取数据，另一个事务在修修改事务）

虚读/幻读: 读取的数据量和事务库不一致(一个事务在读取事务，另一个事务在删除或新增)

spring和mybatis整合

1.导入依赖(基于jdbc的依赖)

1 <dependency>

2 <groupId>org.mybatis</groupId>

3 <artifactId>mybatis</artifactId>

4 <version>3.4.5</version>

5 </dependency>

6 <dependency>

7 <groupId>org.mybatis</groupId>

8 <artifactId>mybatis‐spring</artifactId>

9 <version>1.3.1</version>

10 </dependency>

2.注入流程

dataSource -->sqlSessionFactory--->Dao-->Service-->Controller

1 <!‐‐sqlSessionFactory mybatis的核心配置文件‐‐>

2 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

3 <property name="dataSource" ref="druidDS"></property>

4 <property name="typeAliasesPackage" value="org.itany.domain"></property>

5 <property name="mapperLocations" value="classpath:mapper/*Mapper.xml"></property>

6 </bean>

8 <!‐‐Dao 在Mybatis中没有实现类型使用的为代理模式‐‐>

9 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

10 <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>

11 <property name="basePackage" value="org.itany.dao"></property>

12 </bean>

spring和hibernate的整合

1添加依赖(基于jdbc的依赖)

----------------------- Page 21-----------------------

1 <dependency>

2 <groupId>org.hibernate</groupId>

3 <artifactId>hibernate‐core</artifactId>

4 <version>5.2.9.Final</version>

5 </dependency>

6 <dependency>

7 <groupId>org.springframework</groupId>

8 <artifactId>spring‐oxm</artifactId>

9 <version>${spring.version}</version>

10 </dependency>

11 <dependency>

12 <groupId>org.springframework</groupId>

13 <artifactId>spring‐orm</artifactId>

14 <version>${spring.version}</version>

15 </dependency>

2.注入过程

dataSource--->SessionFactory--->Dao--->Service--->Controller

1 <!‐‐sessionFactory‐‐>

2 <bean id="sessionFactory"

3 class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

4 <property name="dataSource" ref="dataSource"></property>

5 <!‐‐ 可选配置 ‐‐>

6 <property name="hibernateProperties">

7 <props>

8 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

9 <prop key="hibernate.format_sql">true</prop>

10 <!‐‐ 保证通过session.getCurrentSession()获取到的session为线程单例 ‐‐>

11 <prop

key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSess

ionContext

12 </prop>

13 </props>

14 </property>

15 <property name="packagesToScan">

16 <list>

17 <value>org.itany.domain</value>

18 </list>

19 </property>

20 </bean>

对于post请求乱码处理:web.xml

----------------------- Page 22-----------------------

1 <!‐‐ 乱码 ‐‐>

2 <filter>

3 <filter‐name>encodingFilter</filter‐name>

4 <filter‐class>org.springframework.web.filter.CharacterEncodingFilter</filter‐

class>

5 <init‐param>

6 <param‐name>encoding</param‐name>

7 <param‐value>UTF‐8</param‐value>

8 </init‐param>

9 </filter>

11 <filter‐mapping>

12 <filter‐name>encodingFilter</filter‐name>

13 <url‐pattern>/*</url‐pattern>

14 </filter‐mapping>

posted @ 2017-10-05 21:52 王子箫阅读(632) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Spring快速入门

公告