---恢复内容开始---
spring框架主要核心的部分分为两个部分：
aop:面向切面编程 不通过修改源代码,对功能进行扩张增强
ioc:控制反转 通常我们建立对象都是通过new的形式进行创建对象，但是我们这里是通过交给spring来进行创建对象
什么是spring？
spring为一个开源轻量级框架 他是一个一站式框架 对javeee的3层结构都提供了不同的技术
有什么用？
具体的用法分为ioc与aop两个方面
ioc的底层原理：
配置xml文件
dom4J进行解析
得到class路径也就是名称
通过Class类的newinstance方法创建对象
spring的bean管理(配置xml文件方式)
bean的实例化有3个方面
1.通过无参构造函数进行
2.通过静态工厂来进行创建
<bean id="factory" class="com.jdztc.ioc.Factory" factory-method="getUser"></bean>
getUser为com.jdztc.ioc.Factory类中的静态方法得到对象
3.通过实例工厂来进行创建(就是创建对象的方法不是静态方法)
首先需要进行对对象的创建否则将不能轻松的调用getUser方法
<bean id="factoryshili" class="com.jdztc.bean.FactoryShiLi" ></bean>
<bean id="bean2" factory-bean="factoryshili" factory-method="getUser"></bean>
scope属性的介绍：
他为bean的作用范围
默认值为singleton 为单实例对象
prototype:为多实例对象
request:创建对象把对象放入request中
session:创建对象把对象放入sesison中
gobleSession：创建对象把对象放入session中 具体应用：百度首页登录一次其他应用都可以使用
属性注入介绍：
向对象中的属性注入值
有3种方式：1.set方法进行注入（用的最多）
<bean id="user1" class="com.jdztc.type.User"><property name="username" value="你好"></property></bean>
<property></property>
2.有参构造函数
<!-- 属性注入（构造方法） -->
<bean id="user2" class="com.jdztc.type.UserConstructor">
<constructor-arg name="username" value="你好"></constructor-arg>
</bean>
<constructor-arg>标签
3接口注入方式（不支持）
注入复杂类型属性：
注入对象类型属性：（用的最多）
<!-- 注入对象类型属性 -->
<bean id="dao" class="com.jdztc.type.UserDao"></bean>
<bean id="service" class="com.jdztc.type.UserService">
<property name="userDao" ref="dao"/>
</bean>
P名称空间注入（一个标签不能多个相同的属性）
xmlns:p="http://www.springframework.org/schema/p" <bean id="person" class="com.jdztc.type.Person" p:pname="你不好">
注入arr数组 list集合 map集合 properties集合
arr数组的注入方式很相似
<list><value></value><l/ist>形式有多少个值就有多少个value
map集合
<map><entry key="" vlaue=""></entry></map>
properties
<props><prop key="">你好</prop></props>
ioc与dI的区别
ioc:对象的创建交给spring来创建
DI:依赖注入 给对象中的属性注入值
DI不能单独存在 ，他是建立在ioc的基础之上的
spring整合项目原理
核心配置文件的加载和对象的创建交给服务器来创建，也就是在服务器加载的时候创建
用到的ServletContext和监听器
在web.xml文件中配置
<!--配置监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--指定spring配置文件 --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring2.xml</param-value> </context-param>
原理：使用监听器听到ServletContext创建时，进行了以下操作
1：加载核心配置文件，创建配置文件的对象
2.把配置文件的对象放入servletContext中 setAttribute()方法
3.获取配置文件对象 getAttribute()
spring的bean管理方式(注解方式实现)
导入aopjar包
开启注解扫描
对类.方法.属性都进行扫描
<context:component-scan>
只对类的属性
<context:annotation-config>
注解创建对象
@component(value="对象名")
@controller(value="") web层
@service service层 功能是一致的都能创建对象
@Repository 持久层
@scope配置范围 是单实例还是多实例对象
注解注入属性
@AutoWired 不需要set方法和类的注解的value值无关 主要是根据属性来找
@Resource value值要与类的注解的vlaue保持一致
aop方面：
原理：1.不修改原代码进行对功能的扩展2.采用横向抽取机制
横向抽取机制与纵向抽取机制
纵向抽取：
public class Fu{
publci void add(){
}
}
public Class Zi extends Fu{
public void add(){
super.add()
}
}
横向抽取机制
底层使用动态代理实现
动态代理分为：
jdk动态代理针对有接口的情况
原理：创建接口实现类的代理对象（实现InvocationHandler接口），这个对象有着与实现类相同的功能
package com.jdztc.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 针对有接口的情况，使用jdk的动态代理
* @author 付鹏鹏
*
*/
interface Fuu{
public void add();
}
public class ZhongXiangChouQuDemo implements Fuu{
//要增强的方法即切入点
@Override
public void add() {
// TODO Auto-generated method stub
//实现快速的拉屎 增强拉屎的功能
System.out.println("拉屎");
}
}
/**
* 创建与实现类相同功能的代理类
* @author 付鹏鹏
*
*/
class FuuProxy implements InvocationHandler{
private ZhongXiangChouQuDemo zhongxiang;
/**
* 覆盖其默认构造函数
*/
public FuuProxy(ZhongXiangChouQuDemo zhongxiang) {
this.zhongxiang = zhongxiang;
}
/**
* 生成实现类相同功能的代理对象
*/
public Object getProxy(){
return Proxy.newProxyInstance(zhongxiang.getClass().getClassLoader(), zhongxiang.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
Object result=null;
System.out.println("事物的开启");
result=method.invoke(zhongxiang, args);
System.out.println("事物的结束");
return result;
}
}
具体的调用
//创建jdk动态代理类 /*ZhongXiangChouQuDemo zhongxiang=new ZhongXiangChouQuDemo(); FuuProxy proxy=new FuuProxy(zhongxiang); Fuu fuu=(Fuu) proxy.getProxy(); fuu.add();*/
cglib动态代理 针对没有接口的情况下
原理：创建子类代理对象与子类有着相同的功能（实现methodInterceptor）
package com.jdztc.aop;
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import javassist.util.proxy.MethodHandler;
/**
* 没有接口的情况下 使用cglib动态代理
* @author 付鹏鹏
*
*/
class Dao{
public void add(){
System.out.println("拉屎");
}
}
public class CglibProxyDemo extends Dao{
public void add(){
System.out.println("拉屎");
}
}
/**
* 创建子类的代理对象
* @author 付鹏鹏
*
*/
class CglibProxy implements MethodInterceptor{
private Object terget;
public CglibProxy(Object terget) {
this.terget = terget;
}
public Object getIntercept(){
Enhancer enhancer=new Enhancer();
enhancer.setSuperclass(terget.getClass());
//回调方法
enhancer.setCallback(this);
//创建对象
return enhancer.create();
}
@Override
public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
// TODO Auto-generated method stub
System.out.println("食物开启前");
arg3.invoke(terget, arg2);
System.out.println("事务结束了");
return null;
}
}
具体的调用
Dao cglibProxyDemo=new Dao(); CglibProxy cglibProxy=new CglibProxy(cglibProxyDemo); Dao Dao=(Dao) cglibProxy.getIntercept(); Dao.add();
上面两种方式都对方法进行了增强
aop术语：
切入点：真正被增强的方法
增强或通知：你要实现增强的逻辑
前置增强：在方法执行之前
后置增强：在方法执行之后
异常增强：在方法出现异常时执行
最终通知：在后置之后执行
环绕执行：在方法之前执行 方法之后执行也会执行
切面：将增强具体应用到切入点中的过程
这3个为常用的术语
连接点：类里面有哪些可以被增强，这些方法就是连接点
引介：动态的添加方法和属性
target(目标对象)：代理目标（要增强的类）
wearing(织入)：把增强应用到目标对象的过程
proxy(代理):一个类被aop织入增强后，就产生一个结果代理类
aop操作
基于aspectj的aop操作
aspectj是什么？他是面向切面的框架（把动态代理那些功能进行了封装）
实现方式：
1.基于aspectj的xml配置
2.基于aspectj的注解
引入约束
导入jar包spring-aop spring-aspectj aopaliance aspectj-weaver
使用表达式配置切入点
execution(* cn.itcase.aop.book.add(..))表示配置add切入点
execution(* cn.itcase.aop.Book.*(..))表示配置book类中所有的切入点
execution(* save*(..))匹配所有以save开头的方法
具体的应用
首先要创建对象
<!--创建两个类的对象 -->
<bean id="book" class="com.jdztc.aspectj.Book"></bean>
<bean id="mybook" class="com.jdztc.aspectj.MyBook"></bean>
aop配置
配置切入点
将增强应用到切入点中
<!--aop配置 -->
<aop:config>
<!--*后要有空格 -->
<!-- 配置切入点 -->
<aop:pointcut expression="execution(* com.jdztc.aspectj.Book.*(..))" id="pointcut1"/>
<!-- 配置切面 把增强应用到方法当中的过程-->
<aop:aspect ref="mybook">
<aop:before method="before1" pointcut-ref="pointcut1"/>
<aop:around method="around" pointcut-ref="pointcut1"/>
</aop:aspect>
</aop:config>
package com.jdztc.dao;
public class Book {
public void add(){
System.out.println("add....");
}
}
package com.jdztc.aspectj;
import org.aspectj.lang.ProceedingJoinPoint;
public class MyBook {
public void before1(){
System.out.println("before前置增强...");
}
/**
* 环绕增强
* @throws Throwable
*/
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("方法之前");
//执行方法
proceedingJoinPoint.proceed();
System.out.println("方法之后");
}
}
log4j介绍：
info 只能看到基本信息
debug 可以看到详细的信息
基于aspectj的注解aop操作
1创建对象 2开启aop操作 在增强类中使用 在类的上面使用@Aspectj 在方法的上面使用@Before
具体的例子
<bean id="book" class="com.jdztc.dao.Book"></bean>
<!--增强类-->
<bean id="mybook" class="com.jdztc.service.MyBook"></bean>
<!--开启aop注解操作 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
package com.jdztc.service;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class MyBook {
//value值为切入点
@Before(value = "execution(* com.jdztc.dao.Book.*(..))")
public void before1(){
System.out.println("before1.....");
}
}
JDBCTemplate操作和使用
他与dbutil的使用很相似
dbutil操作实现查询要实现ResultSetHanlder
QueryRunner runner=new QueryRunner(dataSource);
查询对象
runner.query(sql,new BeanHanlder<User>(User.calss))
BeanHanlder为ResuleSetHanlder接口的实现类
runner.query(sql,new ResultlistHanlder<User>(User.class))
ResultListHanlder为ResultSetHanlder接口的实现类
JdbcTemplate实现查询也实现了接口RowMapper
具体的代码：
package com.jdztc.jdbctemplate;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
public class JdbcTemplateQuery {
/**
* jdbc模版查询返回list 使用query方法
*
*/
@Test
public void queryList(){
//创建对象
DriverManagerDataSource dataSource=new DriverManagerDataSource();
//设置数据库连接条件
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/spring");
dataSource.setUsername("root");
dataSource.setPassword("");
//创建jdbc模版对象
JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
String sql="select * from spring_03";
//调用模版的查询的方法queryForObject方法
List<User> list=jdbcTemplate.query(sql,new MyRowMapper());
System.out.println(list);
}
/**
* jdbc模版查询返回对象
*
*/
@Test
public void queryObject(){
//创建对象
DriverManagerDataSource dataSource=new DriverManagerDataSource();
//设置数据库连接条件
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/spring");
dataSource.setUsername("root");
dataSource.setPassword("");
//创建jdbc模版对象
JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
String sql="select * from spring_03 where id=?";
//调用模版的查询的方法queryForObject方法
User user=jdbcTemplate.queryForObject(sql, new MyRowMapper(), 1);
System.out.println(user);
}
/**
* 查询有多少条记录
* 查询返回某一个值 使用queryForObject方法 他的第二个参数 为返回值类型的字节码文件
*/
@Test
public void testCount(){
//创建对象
DriverManagerDataSource dataSource=new DriverManagerDataSource();
//设置数据库连接条件
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/spring");
dataSource.setUsername("root");
dataSource.setPassword("");
//创建jdbc模版对象
JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
String sql="select count(*) from spring_03";
//调用模版的查询的方法queryForObject方法
int a=jdbcTemplate.queryForObject(sql,Integer.class);
System.out.println(a);
}
/**
* jdbc的底层代码
*/
@Test
public void query(){
Connection connection=null;
PreparedStatement preparedStatement=null;
ResultSet rs=null;
//加载驱动
try {
Class.forName("com.mysql.jdbc.Driver");
//建立连接
String url="jdbc:mysql://localhost:3306/spring";
String user="root";
String password="";
connection=DriverManager.getConnection(url, user, password);
String sql="select * from spring_03 where id=?";
//预编译sql语句
preparedStatement=connection.prepareStatement(sql);
preparedStatement.setInt(1,1);;
rs=preparedStatement.executeQuery();
while(rs.next()){
//System.out.println(rs.next());
User user1=new User();
String username=rs.getString("username");
String password1=rs.getString("password");
user1.setPassword(password1);
user1.setUsername(username);
System.out.println(user1);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
if (connection != null) {
connection.close();
}
if (rs != null) {
rs.close();
}
if (preparedStatement != null) {
preparedStatement.close();
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
class MyRowMapper implements RowMapper<User>{
@Override
public User mapRow(ResultSet rs, int arg1) throws SQLException {
// TODO Auto-generated method stub
//不需要遍历结果集 这个已在JdbcTemplate中实现了
User user=new User();
String username = rs.getString("username");
String password = rs.getString("password");
user.setPassword(password);
user.setUsername(username);
return user;
}
}
c3p0连接池
记住这个ComboPooledDataSource对象
spring的事务的介绍
什么是事务？
事务是操作数据库的基本单位 指的是一组操作 这组操作要么都成功要么都失败
事务的特性
原子性：一组操作要么都成功要么都失败
一致型：操作之前之后保持一致
隔离性：多个事务操作一个数据，不影响
持久性：在数据生效后一直是那样
不考虑隔离性产生读问题
脏读 不可重复读 还有虚读
解决读问题：
设置隔离级别
事务管理器
对象platformTransactionManager
spring为不同的持久化技术提供了不同的接口实现
jdbcTemplate 和myBatis DataSourceTransactionManager
hibernate5.0 hibernateTranactionManager
如何配置事务
编程式事务管理（基本不用）
声明式事务管理 :
1 基于xml配置文件形式实现
2 注解方式实现
配置步骤：
1.配置事务管理器
2.配置事务增强
3.配置切面（aop操作）
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 配置DataSource属性 与连接池对应 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 事物增强 根据事物管理器进行事务的增强 -->
<tx:advice id="aaa" transaction-manager="transactionManager">
<tx:attributes>
<!-- 设置事务操作的方法匹配规则 propagation="REQUIRED"设置事务隔离级别 -->
<tx:method name="account*"/>
</tx:attributes>
</tx:advice>
<!-- 配置切面 -->
<aop:config>
<!--配置切入点 -->
<aop:pointcut expression="execution(* com.jdztc.service.OrderService.account(..))" id="pointcut1"/>
<!-- 将增强应用到切入点中 -->
<aop:advisor advice-ref="aaa" pointcut-ref="pointcut1"/>
</aop:config>
注解方式实现
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 配置DataSource属性 与连接池对应 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 开启注解事物 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
在你要配置事务的类的上方加上@Transactional 对类中的所有方法加上事务
ssh框架整合思想：
两个两个进行整合
struts2对spring框架进行整合
action对象交给spring进行管理
spring对hibernate进行整合
将数据库交给spring进行管理 写到spring的配置文件当中
创建sessionFactory 交给spring进行配置
---恢复内容结束---