Spring框架

最新推荐文章于 2023-07-16 15:21:11 发布

想个名字太难

最新推荐文章于 2023-07-16 15:21:11 发布

阅读量117

点赞数

分类专栏：笔记技术文档文章标签： spring

本文链接：https://blog.csdn.net/yonghuliu/article/details/83340190

版权

笔记同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

技术文档

22 篇文章 0 订阅

订阅专栏

Spring总结

1. 1. Spring的概述:
    1. 什么是Spring :

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

EE开发分成三层结构:

* WEB层:Spring MVC.

* 业务层:Bean管理:(IOC)

* 持久层:Spring的JDBC模板.ORM模板用于整合其他的持久层框架.

Expert One-to-One J2EE Design and Development :J2EE的设计和开发:(2002.EJB)

Expert One-to-One J2EE Development without EJB :J2EE不使用EJB的开发.

1. 1. 1. 为什么学习Spring:

方便解耦，简化开发

Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理

AOP编程的支持

Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能

声明式事务的支持

只需要通过配置就可以完成对事务的管理，而无需手动编程

方便程序的测试

Spring对Junit4支持，可以通过注解方便的测试Spring程序

方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持

降低JavaEE API的使用难度

Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

1. 1. 1. Spring的版本:

Spring 3.X 和 Spring4.X

1. 1. Spring的入门案例:(IOC)
    1. IOC的底层实现原理

IOC：Inversion of Control 控制反转. 指的是对象的创建权反转(交给)给Spring.

作用是实现了程序的解耦合.

1. 1. 1. 步骤二:创建web项目,引入Spring的开发包:

1. 1. 1. 步骤三:引入相关配置文件:

log4j.properties

applicationContext.xml

引入约束:

spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

<beans xmlns="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">

</beans>

1. 1. 1. 步骤四:编写相关的类:

public interface UserDao {

public void sayHello();

}

public class UserDaoImpl implements UserDao {

@Override

public void sayHello() {

System.out.println("Hello Spring...");

}

1. 1. 1. 步骤五:完成配置：

1. 1. 1. 步骤六:编写测试程序:

@Test

// Spring的方式：

public void demo2(){

// 创建Spring的工厂类：

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

// 通过工厂解析XML获取Bean的实例.

UserDao userDao = (UserDao) applicationContext.getBean("userDao");

userDao.sayHello();

}

1. 1. 1. IOC和DI:

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

DI :Dependency Injection 依赖注入.需要有IOC的环境,Spring创建这个类的过程中,Spring将类的依赖的属性设置进去.

1. 1. Spring中的工厂:
    1. ApplicationContext:

ApplicatioContext接口有两个实现类:

ClassPathXmlApplicationContext :加载类路径下Spring的配置文件.

FileSystemXmlApplicationContext :加载本地磁盘下Spring的配置文件.

1. 1. 1. BeanFactory:

1. 1. 1. BeanFactory和ApplicationContext的区别:

BeanFactory :是在getBean的时候才会生成类的实例.

ApplicationContext :在加载applicationContext.xml时候就会创建.

1. 1. 配置STS的XML的提示:
    1. Spring配置文件中提示的配置

复制路径:

* http://www.springframework.org/schema/beans/spring-beans.xsd

查找XML Catalog:

点击Add..

1. 1. Spring的相关配置:
    1. id属性和name属性标签的配置

id :Bean起个名字. 在约束中采用ID的约束:唯一. 必须以字母开始，可以使用字母、数字、连字符、下划线、句话、冒号 id:不能出现特殊字符.

name:Bean起个名字. 没有采用ID的约束. name:出现特殊字符.如果<bean>没有id的话 , name可以当做id使用.

* 整合struts1的时候:

1. 1. 1. scope属性：Bean的作用范围.

* singleton :默认值，单例的.

* prototype :多例的.

* request :WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中.

* session :WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中.

* globalSession :WEB项目中,应用在Porlet环境.如果没有Porlet环境那么globalSession相当于session.

1. 1. 1. Bean的生命周期的配置:

通过配置<bean>标签上的init-method作为Bean的初始化的时候执行的方法，配置destroy-method作为Bean的销毁的时候执行的方法。

销毁方法想要执行，需要是单例创建的Bean而且在工厂关闭的时候，Bean才会被销毁.

1. 1. Spring的Bean的管理XML的方式：
    1. Spring的Bean的属性注入:

【构造方法的方式注入属性】

<constructor-arg name="name" value="保时捷"/>

<constructor-arg name="price" value="1000000"/>

</bean>

【set方法的方式注入属性】

</bean>

1. 1. 1. Spring的属性注入：对象类型的注入:

</bean>

1. 1. 1. 名称空间p的属性注入的方式:Spring2.x版本后提供的方式.

第一步:引入p名称空间

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

第二步:使用p名称空间.

* 普通属性: p:属性名称=””

* 对象类型属性: p:属性名称-ref=””

1. 1. 1. SpEL的方式的属性注入:Spring3.x版本后提供的方式.

SpEL：Spring Expression Language.

语法:#{ SpEL }

</bean>

</bean>

引用了另一个类的属性

</bean>

1. 1. 1. 注入复杂类型:

<list>

</list>

</property>

<list>

</list>

</property>

<map>

</map>

</property>

<props>

</props>

</property>

</bean>

1. 1. 1. Spring的分配置文件的开发

一种:创建工厂的时候加载多个配置文件:

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");

二种:在一个配置文件中包含另一个配置文件：

1. 案例代码
  1. 搭建环境:
    1. 创建web项目，引入jar包.

WEB层使用Struts2:

* Struts2开发的基本的包

Spring进行Bean管理:

* Spring开发的基本的包

1. 1. 1. 引入配置文件:

Struts2:

* web.xml

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

* struts.xml

Spring:

* applicationContext.xml

* log4j.properties

1. 1. 1. 引入页面:

1. 1. 1. 创建包结构和类：

1. 1. 1. 在添加页面提交内容到Action:

1. 1. 1. 改写Action类并配置Action：

</action>

</package>

</struts>

1. 1. 1. 在Action调用业务层:

将业务层类配置到Spring中:

</bean>

在Action中获取业务层类:

public String save(){

System.out.println("Action中的save方法执行了...");

System.out.println(customer);

// 传统方式:

/*CustomerService customerService = new CustomerServiceImpl();

customerService.save(customer);*/

// Spring的方式进行操作:

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

CustomerService customerService = (CustomerService) applicationContext.getBean("customerService");

customerService.save(customer);

return NONE;

}

**** 每次请求都会创建一个工厂类,服务器端的资源就浪费了,一般情况下一个工程只有一个Spring的工厂类就OK了.

* 将工厂在服务器启动的时候创建好,将这个工厂放入到ServletContext域中.每次获取工厂从ServletContext域中进行获取.

* ServletContextLinstener :监听ServletContext对象的创建和销毁.

1. 1. Spring整合WEB项目
    1. 引入spring-web.jar包:

配置监听器:

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

1. 1. 1. 改写Action:

/**

* 保存客户的执行的方法：save

public String save(){

// 传统方式:

/*CustomerService customerService = new CustomerServiceImpl();

customerService.save(customer);*/

// Spring的方式进行操作:

/*ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

CustomerService customerService = (CustomerService) applicationContext.getBean("customerService");*/

WebApplicationContext applicationContext =WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());

CustomerService customerService = (CustomerService) applicationContext.getBean("customerService");

System.out.println("Action中的save方法执行了...");

System.out.println(customer);

customerService.save(customer);

return NONE;

}

1. 1. 1. 编写Dao并配置:

</bean>

1. 1. 1. 业务层调用DAO：

public class CustomerServiceImpl implements CustomerService {

private CustomerDao customerDao;

public void setCustomerDao(CustomerDao customerDao) {

this.customerDao = customerDao;

}

…

}

</bean>

Spring_day02总结

1. 相关知识点
  1. Spring的Bean管理:(注解方式)
    1. 步骤一:下载Spring的开发包:

官网：http://spring.io/

下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring解压:(Spring目录结构:)

* docs :API和开发规范.

* libs :jar包和源码.

* schema :约束.

1. 1. 1. 步骤二:创建web项目,引入Spring的开发包:

在Spring的注解的AOP中需要引入spring-aop的jar包。

1. 1. 1. 步骤三:引入相关配置文件:

log4j.properties

applicationContext.xml

引入约束:

spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

* 引入约束:(引入context的约束):

<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.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

1. 1. 1. 步骤四:编写相关的类:

public interface UserDao {

public void sayHello();

}

public class UserDaoImpl implements UserDao {

@Override

public void sayHello() {

System.out.println("Hello Spring...");

}

1. 1. 1. 步骤五:配置注解扫描

<context:component-scan base-package="com.it.spring.demo1"/>

1. 1. 1. 在相关的类上添加注解:

@Component(value="userDao")

public class UserDaoImpl implements UserDao {

@Override

public void sayHello() {

System.out.println("Hello Spring Annotation...");

}

1. 1. 1. 编写测试类:

@Test

public void demo2() {

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

"applicationContext.xml");

UserDao userDao = (UserDao) applicationContext.getBean("userDao");

userDao.sayHello();

}

1. 1. Spring的Bean管理的中常用的注解:
    1. @Component:组件.(作用在类上)

Spring中提供@Component的三个衍生注解:(功能目前来讲是一致的)

* @Controller :WEB层

* @Service :业务层

* @Repository :持久层

这三个注解是为了让标注类本身的用途清晰，Spring在后续版本会对其增强

1. 1. 1. 属性注入的注解:(使用注解注入的方式,可以不用提供set方法.)

@Value :用于注入普通类型.

@Autowired :自动装配:

* 默认按类型进行装配.

* 按名称注入:

* @Qualifier:强制使用名称注入.

@Resource相当于:

* @Autowired和@Qualifier一起使用.

1. 1. 1. Bean的作用范围的注解:

@Scope:

* singleton:单例

* prototype:多例

1. 1. 1. Bean的生命周期的配置:

@PostConstruct :相当于init-method

@PreDestroy :相当于destroy-method

1. 1. Spring的Bean管理的方式的比较:

XML和注解:

* XML :结构清晰.

* 注解 :开发方便.(属性注入.)

实际开发中还有一种XML和注解整合开发:

* Bean有XML配置.但是使用的属性使用注解注入.

1. 1. AOP的概述
    1. 什么是AOP

Spring是解决实际开发中的一些问题:

* AOP解决OOP中遇到的一些问题.是OOP的延续和扩展.

1. 1. 1. 为什么学习AOP

对程序进行增强:不修改源码的情况下.

* AOP可以进行权限校验,日志记录,性能监控,事务控制.

1. 1. 1. Spring的AOP的由来:

AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范.

1. 1. 1. 底层实现:

代理机制:

* Spring的AOP的底层用到两种代理机制：

* JDK的动态代理 :针对实现了接口的类产生代理.

* Cglib的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术生成当前类的子类对象.

1. 1. Spring底层AOP的实现原理:（了解）
    1. JDK动态代理增强一个类中方法:

public class MyJDKProxy implements InvocationHandler {

private UserDao userDao;

public MyJDKProxy(UserDao userDao) {

this.userDao = userDao;

}

// 编写工具方法：生成代理：

public UserDao createProxy(){

UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),

userDao.getClass().getInterfaces(), this);

return userDaoProxy;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

if("save".equals(method.getName())){

System.out.println("权限校验================");

}

return method.invoke(userDao, args);

}

1. 1. 1. Cglib动态代理增强一个类中的方法:

public class MyCglibProxy implements MethodInterceptor{

private CustomerDao customerDao;

public MyCglibProxy(CustomerDao customerDao){

this.customerDao = customerDao;

}

// 生成代理的方法:

public CustomerDao createProxy(){

// 创建Cglib的核心类:

Enhancer enhancer = new Enhancer();

// 设置父类:

enhancer.setSuperclass(CustomerDao.class);

// 设置回调:

enhancer.setCallback(this);

// 生成代理：

CustomerDao customerDaoProxy = (CustomerDao) enhancer.create();

return customerDaoProxy;

}

@Override

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

if("delete".equals(method.getName())){

Object obj = methodProxy.invokeSuper(proxy, args);

System.out.println("日志记录================");

return obj;

}

return methodProxy.invokeSuper(proxy, args);

}

1. 1. Spring的基于AspectJ的AOP开发
    1. AOP的开发中的相关术语:

Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.

Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.

Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

Target(目标对象):代理的目标对象

Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.

spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入

Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类

Aspect(切面): 是切入点和通知（引介）的结合

1. 1. Spring使用AspectJ进行AOP的开发：XML的方式（*****）
    1. 引入相应的jar包

* spring的传统AOP的开发的包

spring-aop-4.2.4.RELEASE.jar

com.springsource.org.aopalliance-1.0.0.jar

* aspectJ的开发包:

com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

spring-aspects-4.2.4.RELEASE.jar

1. 1. 1. 引入Spring的配置文件

引入AOP约束:

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="

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

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

</beans>

1. 1. 1. 编写目标类

创建接口和类:

public interface OrderDao {

public void save();

public void update();

public void delete();

public void find();

}

public class OrderDaoImpl implements OrderDao {

@Override

public void save() {

System.out.println("保存订单...");

}

@Override

public void update() {

System.out.println("修改订单...");

}

@Override

public void delete() {

System.out.println("删除订单...");

}

@Override

public void find() {

System.out.println("查询订单...");

}

1. 1. 1. 目标类的配置

</bean>

1. 1. 1. 整合Junit单元测试

引入spring-test.jar

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class SpringDemo3 {

@Resource(name="orderDao")

private OrderDao orderDao;

@Test

public void demo1(){

orderDao.save();

orderDao.update();

orderDao.delete();

orderDao.find();

}

1. 1. 1. 通知类型

前置通知：在目标方法执行之前执行.

后置通知：在目标方法执行之后执行

环绕通知：在目标方法执行前和执行后执行

异常抛出通知：在目标方法执行出现异常的时候执行

最终通知：无论目标方法是否出现异常最终通知都会执行.

1. 1. 1. 切入点表达式

execution(表达式)

表达式:

[方法访问修饰符] 方法返回值包名.类名.方法名(方法的参数)

public * cn.it.spring.dao.*.*(..)

* cn.it.spring.dao.*.*(..)

* cn.it.spring.dao.UserDao+.*(..)

* cn.it.spring.dao..*.*(..)

1. 1. 1. 编写一个切面类

public class MyAspectXml {

// 前置增强

public void before(){

System.out.println("前置增强===========");

}

1. 1. 1. 配置完成增强

<aop:config>

<aop:pointcut expression="execution(* cn.it.spring.demo3.OrderDao.save(..))" id="pointcut1"/>

<aop:aspect ref="myAspectXml">

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

</aop:aspect>

</aop:config>

1. 1. 1. 其他的增强的配置：

<aop:config>

<aop:pointcut expression="execution(* cn.it.spring.demo3.*Dao.save(..))" id="pointcut1"/>

<aop:pointcut expression="execution(* cn.it.spring.demo3.*Dao.delete(..))" id="pointcut2"/>

<aop:pointcut expression="execution(* cn.it.spring.demo3.*Dao.update(..))" id="pointcut3"/>

<aop:pointcut expression="execution(* cn.it.spring.demo3.*Dao.find(..))" id="pointcut4"/>

<aop:aspect ref="myAspectXml">

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

<aop:after-returning method="afterReturing" pointcut-ref="pointcut2"/>

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

<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"/>

<aop:after method="after" pointcut-ref="pointcut4"/>

</aop:aspect>

</aop:config>

Spring_day03总结

1. 相关知识点
  1. Spring使用AspectJ进行AOP的开发:注解的方式
    1. 引入相关的jar包:

* spring的传统AOP的开发的包

spring-aop-4.2.4.RELEASE.jar

com.springsource.org.aopalliance-1.0.0.jar

* aspectJ的开发包:

com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

spring-aspects-4.2.4.RELEASE.jar

1. 1. 1. 引入Spring的配置文件

引入AOP约束:

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="

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

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

</beans>

1. 1. 1. 编写目标类:

public class ProductDao {

public void save(){

System.out.println("保存商品...");

}

public void update(){

System.out.println("修改商品...");

}

public void delete(){

System.out.println("删除商品...");

}

public void find(){

System.out.println("查询商品...");

}

1. 1. 1. 配置目标类：

1. 1. 1. 开启aop注解的自动代理:

<aop:aspectj-autoproxy/>

1. 1. 1. AspectJ的AOP的注解:

@Aspect:定义切面类的注解

通知类型:

* @Before :前置通知

* @AfterReturing :后置通知

* @Around :环绕通知

* @After :最终通知

* @AfterThrowing :异常抛出通知.

@Pointcut:定义切入点的注解

1. 1. 1. 编写切面类:

@Aspect

public class MyAspectAnno {

@Before("MyAspectAnno.pointcut1()")

public void before(){

System.out.println("前置通知===========");

}

@Pointcut("execution(* cn.it.spring.demo4.ProductDao.save(..))")

private void pointcut1(){}

}

1. 1. 1. 配置切面:

1. 1. 1. 其他通知的注解:

@Aspect

public class MyAspectAnno {

@Before("MyAspectAnno.pointcut1()")

public void before(){

System.out.println("前置通知===========");

}

@AfterReturning("MyAspectAnno.pointcut2()")

public void afterReturning(){

System.out.println("后置通知===========");

}

@Around("MyAspectAnno.pointcut3()")

public Object around(ProceedingJoinPoint joinPoint) throws Throwable{

System.out.println("环绕前通知==========");

Object obj = joinPoint.proceed();

System.out.println("环绕后通知==========");

return obj;

}

@AfterThrowing("MyAspectAnno.pointcut4()")

public void afterThrowing(){

System.out.println("异常抛出通知========");

}

@After("MyAspectAnno.pointcut4()")

public void after(){

System.out.println("最终通知==========");

}

@Pointcut("execution(* cn.it.spring.demo4.ProductDao.save(..))")

private void pointcut1(){}

@Pointcut("execution(* cn.it.spring.demo4.ProductDao.update(..))")

private void pointcut2(){}

@Pointcut("execution(* cn.it.spring.demo4.ProductDao.delete(..))")

private void pointcut3(){}

@Pointcut("execution(* cn.it.spring.demo4.ProductDao.find(..))")

private void pointcut4(){}

}

1. 相关知识点
  1. Spring的JDBC的模板:
    1. Spring提供了很多持久层技术的模板类简化编程:

1. 1. 1. 创建数据库和表:

1. 1. 1. 引入相关开发包:

Spring的基本的开发包需要引入的:6个.

1. 1. 1. 创建一个测试类:

@Test

// JDBC模板的基本使用：

public void demo1(){

DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql:///spring_day03");

dataSource.setUsername("root");

dataSource.setPassword("123");

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

jdbcTemplate.update("insert into account values (null,?,?)", "会希",10000d);

}

1. 1. 将连接池的配置交给Spring管理:
    1. Spring内置的连接池的配置：

【引入Spring的配置文件】

【配置内置连接池】

</bean>

【将模板配置到Spring中】

</bean>

【编写测试类】

**** 引入spring-aop.jar

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class SpringDemo2 {

@Resource(name="jdbcTemplate")

private JdbcTemplate jdbcTemplate;

@Test

public void demo1(){

jdbcTemplate.update("insert into account values (null,?,?)", "凤姐",10000d);

}

1. 1. 1. Spring中配置DBCP连接池:

【引入dbcp连接池的jar包】

【配置连接池】

</bean>

1. 1. 1. 配置c3p0连接池:

【引入相应的jar包】

com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar

【配置连接池】

</bean>

1. 1. JDBC模板的CRUD的操作：
    1. JDBC模板CRUD的操作:

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class SpringDemo3 {

@Resource(name="jdbcTemplate")

private JdbcTemplate jdbcTemplate;

@Test

// 插入操作

public void demo1(){

jdbcTemplate.update("insert into account values (null,?,?)", "冠希",10000d);

}

@Test

// 修改操作

public void demo2(){

jdbcTemplate.update("update account set name=?,money =? where id = ?", "思雨",10000d,5);

}

@Test

// 删除操作

public void demo3(){

jdbcTemplate.update("delete from account where id = ?", 5);

}

@Test

// 查询一条记录

public void demo4(){

Account account = jdbcTemplate.queryForObject("select * from account where id = ?", new MyRowMapper(), 1);

System.out.println(account);

}

@Test

// 查询所有记录

public void demo5(){

List<Account> list = jdbcTemplate.query("select * from account", new MyRowMapper());

for (Account account : list) {

System.out.println(account);

}

class MyRowMapper implements RowMapper<Account>{

@Override

public Account mapRow(ResultSet rs, int rowNum) throws SQLException {

Account account = new Account();

account.setId(rs.getInt("id"));

account.setName(rs.getString("name"));

account.setMoney(rs.getDouble("money"));

return account;

}

1. 1. 事务的回顾:
    1. 什么是事务:

事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.

1. 1. 1. 事务特性:

原子性 :强调事务的不可分割.

一致性 :事务的执行的前后数据的完整性保持一致.

隔离性 :一个事务执行的过程中,不应该受到其他事务的干扰

持久性 :事务一旦结束,数据就持久到数据库

1. 1. 1. 如果不考虑隔离性引发安全性问题:

脏读 :一个事务读到了另一个事务的未提交的数据

不可重复读 :一个事务读到了另一个事务已经提交的update的数据导致多次查询结果不一致.

虚读 :一个事务读到了另一个事务已经提交的insert的数据导致多次查询结果不一致.

1. 1. 1. 解决读问题:设置事务隔离级别

未提交读 :脏读，不可重复读，虚读都有可能发生

已提交读 :避免脏读。但是不可重复读和虚读有可能发生

可重复读 :避免脏读和不可重复读.但是虚读有可能发生.

串行化的 :避免以上所有读问题.

1. 1. Spring进行事务管理一组API
    1. PlatformTransactionManager:平台事务管理器.

***** 真正管理事务的对象

org.springframework.jdbc.datasource.DataSourceTransactionManager 使用Spring JDBC或iBatis 进行持久化数据时使用

org.springframework.orm.hibernate3.HibernateTransactionManager 使用Hibernate版本进行持久化数据时使用

1. 1. 1. TransactionDefinition:事务定义信息

事务定义信息:

* 隔离级别

* 传播行为

* 超时信息

* 是否只读

1. 1. 1. TransactionStatus:事务的状态

记录事务的状态

1. 1. 1. Spring的这组接口是如何进行事务管理：

平台事务管理根据事务定义的信息进行事务的管理,事务管理的过程中产生一些状态,将这些状态记录到TransactionStatus里面

1. 1. 1. 事务的传播行为

PROPAGION_XXX :事务的传播行为

* 保证同一个事务中

PROPAGATION_REQUIRED 支持当前事务，如果不存在就新建一个(默认)

PROPAGATION_SUPPORTS 支持当前事务，如果不存在，就不使用事务

PROPAGATION_MANDATORY 支持当前事务，如果不存在，抛出异常

* 保证没有在同一个事务中

PROPAGATION_REQUIRES_NEW 如果有事务存在，挂起当前事务，创建一个新的事务

PROPAGATION_NOT_SUPPORTED 以非事务方式运行，如果有事务存在，挂起当前事务

PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常

PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行

1. 案例代码
  1. 搭建转账的环境:
    1. 创建业务层和DAO的类

public interface AccountService {

public void transfer(String from,String to,Double money);

}

public class AccountServiceImpl implements AccountService {

// 业务层注入DAO:

private AccountDao accountDao;

public void setAccountDao(AccountDao accountDao) {

this.accountDao = accountDao;

}

@Override

/**

* from:转出的账号

* to:转入的账号

* money：转账金额

public void transfer(String from, String to, Double money) {

accountDao.outMoney(from, money);

accountDao.inMoney(to, money);

}

public interface AccountDao {

public void outMoney(String from,Double money);

public void inMoney(String to,Double money);

}

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

@Override

public void outMoney(String from, Double money) {

this.getJdbcTemplate().update("update account set money = money - ? where name = ?", money,from);

}

@Override

public void inMoney(String to, Double money) {

this.getJdbcTemplate().update("update account set money = money + ? where name = ?", money,to);

}

1. 1. 1. 配置业务层和DAO

</bean>

</bean>

1. 1. 1. 编写测试类

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext2.xml")

public class SpringDemo4 {

@Resource(name="accountService")

private AccountService accountService;

@Test

// 转账的测试:

public void demo1(){

accountService.transfer("会希", "凤姐", 1000d);

}

1. 1. Spring的编程式事务(了解)

手动编写代码完成事务的管理:

1. 1. 1. 配置事务管理器

</bean>

1. 1. 1. 配置事务管理的模板

</bean>

1. 1. 1. 需要在业务层注入事务管理模板

</bean>

1. 1. 1. 手动编写代码实现事务管理

public void transfer(final String from, final String to, final Double money) {

transactionTemplate.execute(new TransactionCallbackWithoutResult() {

@Override

protected void doInTransactionWithoutResult(TransactionStatus status) {

accountDao.outMoney(from, money);

int d = 1 / 0;

accountDao.inMoney(to, money);

}

});

}

1. 1. Spring的声明式事务管理XML方式(*****)：思想就是AOP.

不需要进行手动编写代码，通过一段配置完成事务管理

1. 1. 1. 引入AOP开发的包

aop联盟.jar

Spring-aop.jar

aspectJ.jar

spring-aspects.jar

1. 1. 1. 恢复转账环境

1. 1. 1. 配置事务管理器

</bean>

1. 1. 1. 配置事务的通知

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

<tx:attributes>

<!--

isolation="DEFAULT" 隔离级别

propagation="REQUIRED" 传播行为

read-only="false" 只读

timeout="-1" 过期时间

rollback-for="" -Exception

no-rollback-for="" +Exception

-->

<tx:method name="transfer" propagation="REQUIRED"/>

</tx:attributes>

</tx:advice>

1. 1. 1. 配置aop事务

<aop:config>

<aop:pointcut expression="execution(* cn.it.transaction.demo2.AccountServiceImpl.transfer(..))" id="pointcut1"/>

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

</aop:config>

1. 1. Spring的声明式事务的注解方式: (*****)
    1. 引入jar包:

1. 1. 1. 恢复转账环境:

1. 1. 1. 配置事务管理器:

</bean>

1. 1. 1. 开启事务管理的注解:

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

1. 1. 1. 在使用事务的类上添加一个注解：@Transactional

Spring_day04总结

1. 相关知识点：
  1. SSH简单的回顾:
    1. SSH的基本开发回顾

1. 1. SSH框架的整合方式一：零障碍整合(带有Hibernate配置文件)
    1. 创建web项目，引入相关jar包.

【Struts2】

D:\struts2\struts-2.3.24\apps\struts2-blank\WEB-INF\lib\*.jar

Struts2需要了解的jar包:

struts2-convention-plugin-2.3.24.jar ---Struts2注解的开发包.

struts2-json-plugin-2.3.24.jar ---Struts2整合AJAX返回JSON数据.

struts2-spring-plugin-2.3.24.jar ---Struts2整合Spring的插件包.

【Hibernate】

D:\hibernate-release-5.0.7.Final\lib\required\*.jar

日志记录:

log4j的包由Spring引入.

数据库驱动:

Hibernate引入连接池:

D:\hibernate-release-5.0.7.Final\lib\optional\c3p0\*.jar

【Spring】

基本的开发:

AOP开发:

JDBC开发:

事务管理的开发:

整合Hibernate:

整合web项目：

1. 1. 1. 引入相关的配置文件:

【Struts2】

web.xml

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

struts.xml

【Hibernate】

核心配置：hibernate.cfg.xml

映射文件：

【Spring】

web.xml

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

applicationContext.xml

log4j.propertiess

1. 1. 1. 引入相关的页面并进行修改:

1. 1. 1. 创建包结构和相关的类:

1. 1. 1. Struts2和Spring的整合:方式一：Action类由Struts2自己创建

【编写Action中的save方法】

/**

* 保存客户的执行的方法:save

public String save(){

System.out.println("Action中的save方法执行了...");

return NONE;

}

【配置Action类】

</action>

</package>

【在Action中调用业务层的类】

配置Service:

</bean>

在Action中调用

// 传统方式的写法

WebApplicationContext webApplicationContext = WebApplicationContextUtils

.getWebApplicationContext(ServletActionContext.getServletContext());

CustomerService customerService = (CustomerService) webApplicationContext.getBean("customerService");

***** 这种写法很麻烦的，因为需要在每个Action中的每个方法上获取工厂，通过工厂获得类.

为了简化这个代码引入一个插件的包:

struts2-spring-plugin-2.3.24.jar

在这个插件中开启一个Struts2常量

* <constant name="struts.objectFactory" value="spring" />

* 默认的情况下struts2将这个常量关闭的，现在引入插件以后，将常量开启了，引发下面的一些常量生效.

struts.objectFactory.spring.autoWire = name

那么就可以在Action中提供想注入的属性了:

public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {

// 模型驱动使用的对象

private Customer customer = new Customer();

@Override

public Customer getModel() {

return customer;

}

// 注入业务层的类:

private CustomerService customerService;

public void setCustomerService(CustomerService customerService) {

this.customerService = customerService;

}

/**

* 保存客户的执行的方法:save

public String save() {

System.out.println("Action中的save方法执行了...");

// 传统方式的写法

/*WebApplicationContext webApplicationContext = WebApplicationContextUtils

.getWebApplicationContext(ServletActionContext.getServletContext());

CustomerService customerService = (CustomerService) webApplicationContext.getBean("customerService");*/

// 自动注入

customerService.save(customer);

return NONE;

}

【在Service中编写save方法】

public class CustomerServiceImpl implements CustomerService {

@Override

public void save(Customer customer) {

System.out.println("Service中的save方法执行了...");

}

1. 1. 1. Struts2和Spring的整合方式二:Action类由Spring创建.（推荐）

【引入插件包】

struts2-spring-plugin-2.3.24.jar

【Action交给Spring管理】

将Action配置到Spring中.

<!—必须手动注入属性-->

</bean>

Action的配置：

</action>

</package>

1. 1. 1. 在业务层调用DAO

【将DAO配置到Spring中】

</bean>

【在业务层注入Dao】

public class CustomerServiceImpl implements CustomerService {

// 注入Dao

private CustomerDao customerDao;

public void setCustomerDao(CustomerDao customerDao) {

this.customerDao = customerDao;

}

@Override

public void save(Customer customer) {

System.out.println("Service中的save方法执行了...");

customerDao.save(customer);

}

</bean>

1. 1. 1. Spring整合Hibernate:

【创建映射文件】

<hibernate-mapping>

</id>

</class>

</hibernate-mapping>

【加载到核心配置文件】

【在Spring的配置文件中完成如下配置】

</bean>

【改写DAO】

public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {

@Override

public void save(Customer customer) {

System.out.println("DAO中的save方法执行了...");

}

</bean>

【调用模板中的方法】

@Override

public void save(Customer customer) {

System.out.println("DAO中的save方法执行了...");

// 保存:

this.getHibernateTemplate().save(customer);

}

1. 1. 1. 配置Spring的事务管理：

【配置事务管理器】

</bean>

【注解事务管理的开启】

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

【在业务层添加一个注解】

1. 1. SSH框架的整合方式二：不带Hibernate的配置文件
    1. 复制一个SSH1的项目.

1. 1. 1. 查看Hibernate的配置文件：

Hibernate的配置文件包含如下内容：

连接数据库必要的参数:

Hibernate的属性:

连接池的配置:

映射文件的引入:

1. 1. 1. 替换数据库连接参数和连接池的配置:

创建jdbc.properties

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql:///ssh1

jdbc.username=root

jdbc.password=123

在Spring中引入外部属性文件

<context:property-placeholder location="classpath:jdbc.properties"/>

配置连接池:

</bean>

1. 1. 1. 配置Hibernate的其他属性及映射:

<props>

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

<prop key="hibernate.hbm2ddl.auto">update</prop>

</props>

</property>

<list>

<value>cn/it/ssh/domain/Customer.hbm.xml</value>

</list>

</property>

</bean>

1. 1. HibernateTemplate的使用:

public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {

@Override

public void save(Customer customer) {

System.out.println("DAO中的save方法执行了...");

// 保存:

this.getHibernateTemplate().save(customer);

}

@Override

public void update(Customer customer) {

this.getHibernateTemplate().update(customer);

}

@Override

public void delete(Customer customer) {

this.getHibernateTemplate().delete(customer);

}

@Override

public Customer findById(Long id) {

return this.getHibernateTemplate().load(Customer.class, id);

}

@Override

public List<Customer> findAllByHQL() {

List<Customer> list = (List<Customer>) this.getHibernateTemplate().find("from Customer");

return list;

}

public List<Customer> findAllByQBC(){

DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);

List<Customer> list = (List<Customer>) this.getHibernateTemplate().findByCriteria(detachedCriteria);

return list;

}

1. 1. 延迟加载的问题的解决：OpenSessionInViewFilter

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

<filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>

</filter>

<filter-mapping>

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

<url-pattern>*.action</url-pattern>

</filter-mapping>

说明：由于个人能力有限，所以有些地方借鉴了他人的经验，如有错误，或者涉及侵权等问题，请及时告知，我会立即修改或者删除。谢谢各位。

想个名字太难

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录