Spring基础--Spring(你必须要懂得基础)

1_Spring概述

作者： 风离紫竹--tryzq521@126.com

2_IOC 作者： 风离紫竹--tryzq521@126.com

1.IOC概述

①含义：Iversion of Control反转控制——反转资源获取的方向

②传统的获取资源的方式

组件向当前所在的环境主动的去要资源

ActionContext.getContext().getSession();

③IOC提倡的方式

由组件所在的环境负责将资源注入到组件中，组件被动接受即可

SessionAware接口→setSession()

④IOC是一种思想，最经典的实现是DI：Dependency Injection依赖注入

2.IOC容器细节

①使用IOC容器创建对象

②使用IOC容器在创建对象的同时，给对象的属性赋值

③在创建对象的过程中，实现组件对象之间的自动装配

3.搭建Spring IOC容器需要的开发环境

①导入IOC容器需要的jar包

spring-beans-4.0.0.RELEASE.jar

spring-context-4.0.0.RELEASE.jar

spring-core-4.0.0.RELEASE.jar

spring-expression-4.0.0.RELEASE.jar

commons-logging-1.1.3.jar

②创建Spring配置文件：Spring Bean Configuration File

4.IOC容器创建对象

①IOC容器本身对象创建时，会将配置文件中配置好的bean创建出来

②默认是单实例的，只创建bean的一个对象

③如果设置bean的scope属性为prototype，那么创建bean的对象就是多实例的，在获取的时候创建，每次获取对象都会创建新的

5.从IOC容器中获取对象

①根据bean的id获取

②根据bean的类型获取：要求容器中指定类型的bean是唯一的

6.bean的后置处理器

①在bean的初始化方法调用前后执行操作的专门的对象

②自定义后置处理器：org.springframework.beans.factory.config.BeanPostProcessor

7.属性的装配

①手动装配

②自动装配

8.使用注解配置bean

①声明bean的注解

@Component 将当前类声明为IOC容器中的一个普通的组件

@Controller 将当前类声明为IOC容器中的一个控制器组件

@Service 将当前类声明为IOC容器中的业务逻辑层组件

@Repository 将当前类声明为IOC容器中的一个持久化层组件

Spring根据上述注解其实并不能分辨当前类是否真的是一个控制器或Dao，即使标记的类和注解不对应也没有语法错误。但在实际工作中，肯定要将专门的注解标记在对应的类上面。

②使用基于注解的bean的配置，需要额外导入一个jar包：spring-aop-4.0.0.RELEASE.jar

③需要设置自动扫描的包

<context:component-scanbase-package="com.atguigu.ioc.bean"/>

④使用注解后，默认按照类名首字母小写作为id的值，也可以使用value属性指定id，value属性名也可以省略

注解	id值
@Component publicclassCommonComponent{ }	commonComponent
@Controller(value="atguiguBookAction") publicclassBookAction { }	atguiguBookAction
@Service("happyService") publicclassBookService { }	happyService

⑤使用注解进行自动装配：@Autowired注解

[1]首先检测标记了@Autowired注解的属性的类型

[2]根据类型进行装配

[3]如果指定类型的bean不止一个，那么根据需要被装配的属性的属性名做id的值，查找bean

[4]如果根据id值还是没有找到bean，可以使用@Qualifier注解手动指定要装配的bean的id

[5]如果设置@Autowired注解的required属性为false，则不勉强装配属性，如果能够装配则装配，如果不能装配则不装配。

9.泛型依赖注入

3_IOC补充 作者： 风离紫竹--tryzq521@126.com

使用@Scope注解可将bean声明为多实例的

@Scope(value="prototype")

4_AOP 作者： 风离紫竹--tryzq521@126.com

1.概念：Aspect Oriented Programming 面向切面编程

2.作用：本质上来说是一种简化代码的方式

• 继承机制
• 封装方法
• 动态代理
• ……

3.情景举例

①数学计算器接口

int add(int i,int j); int sub(int i,int j); int mul(int i, int j); int div(int i,int j);

②提供简单实现

③在简单实现的基础上让每一个计算方法都能够打印日志

④缺陷

[1]手动添加日志繁琐，重复

[2]统一修改不便

[3]对目标方法本来要实现的核心功能有干扰，使程序代码很臃肿，不易于开发维护

⑤使用动态代理实现

[1]创建一个类，让这个类能够提供一个目标对象的代理对象

[2]在代理对象中打印日志

4.AOP术语

5.在Spring中使用AOP实现日志功能

①Spring中可以使用注解或XML文件配置的方式实现AOP。

②导入jar包

  com.springsource.net.sf.cglib -2.2.0.jar

  com.springsource.org.aopalliance-1.0.0 .jar

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

  commons-logging-1.1.3. jar

  spring-aop-4.0.0.RELEASE.jar

  spring-aspects-4.0.0.RELEASE.jar

  spring-beans-4.0.0.RELEASE.jar

  spring-context-4.0.0.RELEASE.jar

  spring-core-4.0.0.RELEASE.jar

  spring-expression-4.0.0.RELEASE. jar

③开启基于注解的AOP功能

<aop:aspectj-autoproxy/>

④声明一个切面类，并把这个切面类加入到IOC容器中

@Aspect//表示这是一个切面类 @Component//加入IOC容器 publicclassLogAspect { }

⑤在切面类中声明通知方法

[1]前置通知：@Before

[2]返回通知：@AfterReturning

[3]异常通知：@AfterThrowing

[4]后置通知：@After

[5]环绕通知：@Around

⑥被代理的对象也需要加入IOC容器

6.切入点表达式

①最详细

execution(public int com.atguigu.aop.target.EazyImpl.add(int,int))

②最模糊

execution(* *.*(..))

7.统一声明切入点表达式

@Pointcut(value="execution(public int com.atguigu.aop.target.EazyImpl.add(int,int))")      publicvoidmyPointCut(){}

8.通知方法的细节

①在前置通知中获取目标方法的方法名和参数列表

[1]在通知方法中声明一个JoinPoint类型的形参

[2]调用JoinPoint对象的getSignature()方法获取目标方法的签名

[3]调用JoinPoint对象的getArgs()方法获取目标方法的实际参数列表

②在返回通知中获取方法的返回值

[1]在@AfterReturning注解中添加returning属性

@AfterReturning(value="myPointCut()",returning="result")

[2]在返回通知的通知方法中声明一个形参，形参名和returning属性的值一致

showReturnLog(JoinPoint joinPoint, Objectresult)

③在异常通知中获取异常对象

[1]在@ AfterThrowing注解中添加throwing属性

@AfterThrowing(value="myPointCut()",throwing="throwable")

[2]在异常通知的通知方法中声明一个形参，形参名和throwing属性值一致

showExceptinLog(JoinPoint joinPoint, Throwablethrowable)

9.真正放在IOC容器中的对象是代理对象，而并不是目标对象本身

10.切面的优先级

对于同一个代理对象，可以同时有多个切面共同对它进行代理。

可以通过@Order (value=50)注解来进行设置，值越小优先级越高

5_JdbcTemplate 作者： 风离紫竹--tryzq521@126.com

1.Spring提供的一个操作数据库的技术，是对Jdbc的封装。语法风格非常接近DBUtils。

2.配置环境

①导入jar包

[1]IOC容器需要的jar包

[2]MySQL驱动、C3P0jar包

[3]JdbcTemplate需要的jar包

②在IOC容器中配置数据源

③在IOC容器中配置JdbcTemplate对象的bean，并将数据源对象装配到JdbcTemplate对象中

6_声明式事务 作者： 风离紫竹--tryzq521@126.com

1.编程式事务

//1.获取Connection对象 Connection conn = JDBCUtils.getConnection(); try { //2.开启事务：取消自动提交 conn.setAutoCommit(false); //3.执行数据库操作 chain.doFilter(req,resp); //4.提交事务 conn.commit(); }catch(Exception e) { //5.回滚事务 conn.rollBack(); }finally{ //6.释放资源 }

2.声明式事务

①基本原理：AOP

[1]前置通知：开启事务

[2]返回通知：提交事务

[3]异常通知：回滚事务

[4]后置通知：释放资源

②事务管理器

③导入jar包

[1]IOC容器需要的jar包

[2]AOP需要的jar包

[3]JdbcTemplate操作需要的jar包

[5]MySQL驱动和C3P0

④配置

[1]配置数据源

[2]配置JdbcTemplate，并装配数据源

[3]配置事务管理器，并装配数据源

<beanid="dataSourceTransactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">           <propertyname="dataSource"ref="dataSource"/>      </bean>

[4]开启基于注解的声明式事务功能

<tx:annotation-driventransaction-manager="dataSourceTransactionManager"/>

如果事务管理器的bean的id正好是transaction-manager的默认值transactionManager，则可以省略

[5]在事务方法上加@Transactional注解

3.情景举例

①导入SQL文件：declaration_transaction.sql

②数据库操作

[1]根据isbn的值查询书的价格

[2]根据isbn的值减少书的库存，假设每次都只买1本书

[3]根据用户名减少用户账户中的余额，减少的额度就是书的价格

4.事务属性的设置

①事务的传播行为

[1]一个事务运行在另一个有事务的方法中，那么当前方法是开启新事务还是在原有的事务中运行。

[2]设置事务方法在调用其他事务方法时，自己的事务如何传播给被调用的方法。

[3]设置方式

@Transactional(propagation=Propagation.REQUIRES_NEW)

②事务的隔离级别

isolation=Isolation.READ_COMMITTED

③事务根据什么异常不进行回滚

noRollbackFor=ArithmeticException.class

④事务的超时属性

[1]数据库事务在执行过程中，会占用数据库资源，所以如果某一个事务执行的时间太长，那么就会导致资源被长时间占用，影响其他事务执行。

[2]可以通过设置超时属性，将超时没有执行完的事务回滚。

timeout=3

⑤事务的只读属性

数据库会对事务进行优化，如果是一个查询操作，那么数据库可以有针对性的进行优化。我们可以通过设置事务属性，告诉数据库当前操作是一个只读操作，便于数据库进行优化。

readOnly=true

5.基于XML的声明式事务

<!-- 配置基于XML的声明式事务 -->      <!-- 声明切入点表达式 -->      <aop:config>           <aop:pointcutexpression="execution(* com.atguigu.tx.component.BookService.doCash(String, String))"                          id="txPointCut"/>           <!-- 将事务切入点和事务建议的配置关联起来 -->           <aop:advisoradvice-ref="bookTransaction"pointcut-ref="txPointCut"/>      </aop:config>            <!-- 设置事务属性 -->      <tx:adviceid="bookTransaction"transaction-manager="dataSourceTransactionManager">           <tx:attributes>               <tx:methodname="doCash"                           propagation="REQUIRED"                           isolation="READ_COMMITTED"                           read-only="false"                           no-rollback-for="java.lang.ArithmeticException"                           timeout="3"                           />                                          <!-- 将某一类方法统一设置为只读 -->               <tx:methodname="get*"read-only="true"/>               <tx:methodname="find*"read-only="true"/>               <tx:methodname="query*"read-only="true"/>           </tx:attributes>      </tx:advice>

7_整合Hibernate 作者： 风离紫竹--tryzq521@126.com

1.整合目标

3.Spring为SessionFactory接口提供了一个可以被配置为bean的实现类：org.springframework.orm.hibernate4.LocalSessionFactoryBean

4.事务管理器：org.springframework.orm.hibernate4.HibernateTransactionManager

5.在Dao中获取Session对象

①factory .openSession()

开启新的会话，返回一个新创建的Session对象

②factory .getCurrentSession()

从当前线程上获取Session对象，保证多个数据库操作在同一个事务中

注意：在Spring和Hibernate整合环境下，当前方法必须运行在声明式事务中才能够通过getCurrentSession()获取到Session对象。

publicSession getSession() {            //测试Dao的方法时，使用openSession()      returnfactory.openSession();            //运行在事务方法中时，使用getCurrentSession()      //return factory.getCurrentSession(); }

8_整合Struts2 作者： 风离紫竹--tryzq521@126.com

1.在Web应用中使用Spring

①创建IOC容器对象

②Web应用工作阶段：初始化阶段→请求响应阶段→卸载前清理

③在Web应用初始化阶段将IOC容器对象创建出来，并保存到application域中。

④在ServletContextListener监听器中执行如下操作

[1]创建IOC容器对象

[2]将IOC容器对象保存到application域中

2.整合Struts2

①导入jar包

[1]Spring需要的jar包

IOC容器需要的jar包

Web应用相关的jar包

spring-web-4.0.0.RELEASE.jar spring-webmvc-4.0.0.RELEASE.jar

[2]Struts2需要的jar包

[3]Struts2提供的一个用于整合Spring的插件jar包

LibrarySupport\struts-2.3.15.3\lib

struts2-spring-plugin-2.3.15.3.jar

②配置Spring提供的一个专门用于创建IOC容器对象的监听器

<!-- 配置Web应用的初始化参数，指定Spring配置文件的位置 -->      <context-param>           <param-name>contextConfigLocation</param-name>           <param-value>classpath:applicationContext.xml</param-value>      </context-param>      <!-- 配置加载IOC容器的监听器 -->      <listener>           <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>      </listener>

③导入Struts2自身的配置文件，配置核心Filter

④将Struts2的Action类设置为多实例方式创建

@Scope(value="prototype")

⑤Struts2整合Spring后，Action类的对象交给IOC容器创建，那么在class属性中，就可以使用Action类的bean的id

9_CRUD练习 作者： 风离紫竹--tryzq521@126.com

1.功能描述

[1]显示员工列表，要求显示员工列表时显示部门名称

[2]添加员工，在添加界面显示所有部门列表，供选择

[3]更新员工，在更新界面显示所有部门列表，供选择，并且初始状态下显示当前员工现在的部门

[4]删除员工

[5]以上所有增删改操作执行完成后都回到列表页面

2.项目结构

①实体类

Employee

Department

②组件

持久化层：HibernateDao/HibernateDaoImpl

Tips：在使用openSession()方式单独测试Dao方法时，update()和delete()方法需要工作在事务中才有效

业务逻辑层：EmployeeService/EmployeeServiceImpl

表示层：EmployeeAction

③页面

index.jsp：显示“前往员工列表”超链接

showEmpList.jsp：显示员工列表

addUI.jsp：显示添加员工信息的表单界面

editUI.jsp：显示编辑员工信息的表单界面

④配置文件

Spring配置文件

Hibernate配置文件：cfg/hbm

Struts2配置文件

web.xml配置文件

jdbc.properties属性文件

★配置文件可以专门创建一个Source Folder来保存，源码目录中的内容经过项目编译后会被保存到类路径下

⑤jar包

[1]MySQL和数据库连接池

[2]Spring

IOC容器

AOP

jdbc

web

[3]Hibernate

[4]Struts2：整合Spring时需要用到的插件

3.实现步骤

①创建数据库：ssh_crud0917

②导入所需要的jar包

③使用Spring的IOC容器创建数据源对象

4.OpenSessionInViewFilter

作用：将Hibernate的Session的开启时间延长到JSP页面执行完成。

配置

<!-- 配置OpenSessionInViewFilter -->      <filter>           <filter-name>OpenSessionInView</filter-name>           <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>      </filter>      <filter-mapping>           <filter-name>OpenSessionInView</filter-name>           <url-pattern>/*</url-pattern>      </filter-mapping>

5.配置使用二级缓存

①导入二级缓存jar包

hibernate-release-4.2.4.Final\lib\optional\ehcache\全部

②导入二级缓存自身的配置文件

hibernate-release-4.2.4.Final\project\etc\ehcache.xml

③在Hibernate中开启二级缓存功能

④配置Department类开启二级缓存功能

⑤开启查询缓存功能

⑥让Query对象setCacheable(true)