spring框架总结

---恢复内容开始---

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>

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

properties

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进行配置

---恢复内容结束---

posted @ 2017-05-22 17:37 0101无限的空间阅读(180) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

0101无限的空间

spring框架总结

scope属性的介绍：

aop操作

公告