Spring

Spring是一个轻量级的容器,他实现了IOC和非侵入的框架,并提供了AOP的实现方式,提供了持久层事务的支持,其让Java开发模块化,并且贯穿持久层、逻辑层、表现层,让每一个模块都可以独立分开,降低耦合,提高代码复用率。
Spring 框架宗旨:不重新发明技术,让原有技术使用起来更加方便.Spring 几大核心功能

Spring用到了那些设计模式
代理模式—在AOP和remoting中被用的比较多。
单例模式—在spring配置文件中定义的bean默认为单例模式
模板方法—用来解决代码重复的问题。
前端控制器—Spring提供了DispatcherServlet来对请求进行分发。
工厂模式—BeanFactory用来创建对象的实例。
依赖注入—贯穿于BeanFactory / ApplicationContext接口的核心理念

  1. IoC/DI 控制反转/依赖注入
  2. AOP 面向切面编程
  3. 声明事务

Spring 框架 runtime (运行环境)
1test:spring 提供测试功能
2CoreContainer:核心容器.Spring 启动最基本的条件.
2.1Beans:Spring 负责创建类对象并管理对象
2.2Core: 核心类
2.3Context: 上下文参数.获取外部资源或这管理注解等
2.4SpEl:expression.jar
3AOP: 实现 aop 功能需要依赖
4Aspects: 切面 AOP 依赖的包
5DataAccess/Integration:spring 封装数据访问层相关内容
5.1JDBC:Spring 对 JDBC 封装后的代码.
5.2ORM: 封装了持久层框架的代码.例如 Hibernate
5.3transactions:对应 spring-tx.jar,声明式事务使用.
6WEB:需要 spring 完成 web 相关功能时需要.
6.1 例如:由tomcat加载spring配置文件时需要有spring-web
在这里插入图片描述
SpringIOC和DI
IOC是将维护对象和创建对象的工作交给Spring,而不用我们自己去创建和维护
IOC:控制反转
1IoC 完成的事情原先由程序员主动通过 new 实例化对象事情,转交给 Spring 负责.
2 控制反转中控制指的是:控制类的对象.
3 控制反转中反转指的是转交给 Spring 负责.
4IoC 最大的作用:解耦 . 程序员不需要管理对象.解除了对象管理和程序之间的耦合.

DI是注入对象中所需要的属性
DI:依赖注入
DI 和 IoC 是一样的
当一个类(A)中需要依赖另一个类()对象时,把 B 赋值给 A 的过程就叫做依赖注入.

DI的三种方式
构造方法
set方法
接口

AOP
1.AOP:中文名称面向切面编程
2.英文名称:(Aspect Oriented Programming)
3.正常程序执行流程都是纵向执行流程
3.1 又叫面向切面编程,在原有纵向执行流程中添加横切面
3.2 不需要修改原有程序代码
3.2.1 高扩展性
3.2.2 原有功能相当于释放了部分逻辑.让职责更加明确.

4面向切面编程是什么?
4.1 在程序原有纵向执行流程中,针对某一个或某一些方法添加通知,形成横切面过程就叫做面向切面编程.

5.常用概念
5.1 原有功能: 切点,pointcut
5.2 前置通知: 在切点之前执行的功能.beforeadvice
5.3 后置通知: 在切点之后执行的功能,afteradvice
5.4 如果切点执行过程中出现异常,会触发异常通知.throwsadvice
5.5 所有功能总称叫做切面.
5.6 织入: 把切面嵌入到原有功能的过程叫做织入

6.spring 提供了 2 种 AOP 实现方式
6.1Schema-based
6.1.1 每个通知都需要实现接口或类
6.1.2 配置 spring 配置文件时在aop:config配置
6.2AspectJ
6.2.1 每个通知不需要实现接口或类
6.2.2 配置 spring 配置文件是在aop:config的子标签
aop:aspect中配置

代理设计模式

  1. 设计模式:前人总结的一套解决特定问题的代码.
  2. 代理设计模式优点:
    2.1 保护真实对象
    2.2 让真实对象职责更明确.
    2.3 扩展
  3. 代理设计模式
    3.1 真实对象.(老总)
    3.2 代理对象(秘书)
    3.3 抽象对象(抽象功能),谈小目标
    九. 静态代理设计模式
  4. 由代理对象代理所有真实对象的功能.
    1.1 自己编写代理类
    1.2 每个代理的功能需要单独编写
  5. 静态代理设计模式的缺点:
    2.1 当代理功能比较多时,代理类中方法需要写很多.

动态代理

  1. 为了解决静态代理频繁编写代理功能缺点.
  2. 分类:
    2.1JDK 提供的
    2.2cglib 动态代理

JDK 动态代理

  1. 和 cglib 动态代理对比
    1.1 优点:jdk 自带,不需要额外导入 jar
    1.2 缺点:
    1.2.1 真实对象必须实现接口
    1.2.2 利用反射机制.效率不高.
  2. 使用 JDK 动态代理时可能出现下面异常
    2.1 出现原因:希望把接口对象转换为具体真实对象

cglib 动态代理

  1. cglib 优点:
    1.1 基于字节码,生成真实对象的子类.
    1.1.1 运行效率高于 JDK 动态代理.
    1.2 不需要实现接口
  2. cglib 缺点:
    2.1 非 JDK 功能,需要额外导入 jar
  3. 使用 springaop 时,只要出现 Proxy 和真实对象转换异常
    3.1 设置为 true 使用 cglib
    3.2 设置为 false 使用 jdk(默认值)
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

自动注入
1.在 Spring 配置文件中对象名和 ref=”id”id 名相同使用自动注入,可以不配置
2.两种配置办法
2.1 在中通过 autowire=”” 配置,只对这个生效
2.2 在中通过 default-autowire=””配置,表当当前文件中所有都是全局配置内容
3.autowire=”” 可取值
3.1default: 默认值,根据全局 default-autowire=””值.默认全局和局
部都没有配置情况下,相当于 no
3.2no: 不自动注入
3.3byName: 通过名称自动注入.在 Spring 容器中找类的 Id
3.4byType: 根据类型注入.
3.4.1spring 容器中不可以出现两个相同类型的
3.5constructor: 根据构造方法注入.
3.5.1 提供对应参数的构造方法(构造方法参数中包含注入对像)
3.5.2 底层使用 byName, 构造方法参数名和其他的 id相同.
Spring 中加载 properties 文件

  1. 在 src 下新建 xxx.properties 文件
  2. 在 spring 配置文件中先引入 xmlns:context,在下面添加
    2.1 如果需要记载多个配置文件逗号分割
<context:property-placeholder location="classpath:db.properties"/>
  1. 添加了属性文件记载,并且在中开启自动注入注意的地方
    3.1SqlSessionFactoryBean 的 id 不能叫做 sqlSessionFactory
    3.2 修改
    3.2.1 把原来通过ref引用替换成value赋值,自动注入只能影响
    ref,不会影响 value 赋值
 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
	<property name="basePackage" value="com.mapper">						
		</property> 
	<property name="sqlSessionFactoryBeanName" value="factory"
		</property>
 </bean>
  1. 在被Spring管理的类中通过@Value(“${key}”)取出properties中内容
    4.1 添加注解扫描
 <context:component-scan base-package="com.service.impl"></context:compo nent-scan>

4.2 在类中添加
4.2.1key 和变量名可以不相同
4.2.2 变量类型任意,只要保证 key 对应的 value 能转换成这个
类型就可以.

@Value("${my.demo}")
 private String test;

scope 属性

  1. 的属性,
  2. 作用:控制对象有效范围(单例,多例等)
  3. 标签对应的对象默认是单例的.
    3.1 无论获取多少次,都是同一个对象
  4. scope 可取值
    4.1singleton 默认值,单例
    4.2prototype 多例,每次获取重新实例化
    4.3request 每次请求重新实例化
    4.4session 每个会话对象内,对象是单例的.
    4.5application 在 application 对象内是单例
    4.6 global session spring 推 出 的 一 个 对 象 , 依 赖 于
    spring-webmvc-portlet,类似于 session

单例设计模式

  1. 作用: 在应用程序有保证最多只能有一个实例.
  2. 好处:
    2.1 提升运行效率.
    2.2 实现数据共享. 案例:application 对象
  3. 懒汉式
    3.1 对象只有被调用时才去创建.
    3.2 示例代码
public class SingleTon {
	//由于对象需要被静态方法调用,把方法设置为static
	//由于对象是static,必须要设置访问权限修饰符为private ,如果是public可以直接调用对象,不执行访问入口
	private static SingleTon singleton;
	/**
	 * 方法名和类名相同
	 * 无返回值.
	 * 
	 * 
	 * 其他类不能实例化这个类对象
	 * 
	 * 对外提供访问入口
	 */
	private SingleTon(){}
	
	/**
	 * 实例方法,实例方法必须通过对象调用
	 * 
	 * 设置方法为静态方法
	 * 
	 * 
	 * @return
	 */
	public static SingleTon getInstance(){
		//添加逻辑如果实例化过,直接返回
		if(singleton==null){
			/*
			 * 多线程访问下,可能出现if同时成立的情况,添加锁
			 */
			synchronized (SingleTon.class) {
				//双重验证
				if(singleton==null){
					singleton = new SingleTon();
				}
			}
			
		}
		return singleton;
	}
}

3.3 由于添加了锁,所以导致效率低.
4. 饿汉式
4.1 解决了懒汉式中多线程访问可能出现同一个对象和效率低问

public class SingleTon {
//在类加载时进行实例化. 
private static SingleTon singleton=new SingleTon(); 
	private SingleTon(){
	} 
	public static SingleTon getInstance(){ 
	return singleton; 
	}
}

声明式事务
1.编程式事务:
1.1 由程序员编程事务控制代码.
1.2OpenSessionInView 编程式事务
2.声明式事务:
2.1 事务控制代码已经由 spring 写好.程序员只需要声明出哪些方
法需要进行事务控制和如何进行事务控制.
3.声明式事务都是针对于 ServiceImpl 类下方法的.
4.事务管理器基于通知(advice)的.
5.在 spring 配置文件中配置声明式事务

<?xml version="1.0" encoding="UTF-8"?>
<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"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd"
	default-autowire="byName">
    <context:property-placeholder location="classpath:db.properties,classpath:second.properties"/>
    <context:component-scan base-package="com.bjsxt.service.impl"></context:component-scan>
    <!-- 数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    	<property name="driverClassName" value="${jdbc.driver}"></property>
    	<property name="url" value="${jdbc.url}"></property>
    	<property name="username" value="${jdbc.username}"></property>
    	<property name="password" value="${jdbc.password}"></property>
    </bean>
    <!-- SqlSessinFactory对象 -->
    <bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean">
    	<property name="typeAliasesPackage" value="com.bjsxt.pojo"></property>
    </bean>
    <!-- 扫描器 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    	<property name="basePackage" value="com.mapper"></property>
    	<property name="sqlSessionFactoryBeanName" value="factory"></property>
    </bean>
    
    <!-- 注入 -->
   <!--  <bean id="usersService" class="com.service.impl.UsersServiceImpl">
    	<property name=""></property>
    </bean> -->
    <bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 配置声明式事务 -->
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<!-- 哪些方法需要有事务控制 -->
			<!-- 方法以ins开头事务管理 -->
			<tx:method name="ins*" />
			<tx:method name="del*"/>
			<tx:method name="upd*"/>
			<tx:method name="*" read-only="true"/>
		</tx:attributes>
	</tx:advice>
	<aop:config>
		<!-- 切点范围设置大一些 -->
		<aop:pointcut expression="execution(* com.service.impl.*.*(..))"
			id="mypoint" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="mypoint" />
	</aop:config>
    <!-- aop -->
    <!-- <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
    <bean id="mybefore" class="com.advice.MyBefore"></bean>
    <bean id="myafter" class="com.advice.MyAfter"></bean>
    <aop:config>
    	<aop:pointcut expression="execution(* com.service.impl.UsersServiceImpl.login(..))" id="mypoint"/>
    	<aop:advisor advice-ref="mybefore" pointcut-ref="mypoint"/>
    	<aop:advisor advice-ref="myafter" pointcut-ref="mypoint"/>
    </aop:config> -->
</beans>

声明式事务中属性解释

  1. name=”” 哪些方法需要有事务控制
    1.1 支持*通配符
  2. readonly=”boolean” 是否是只读事务.
    2.1 如果为 true,告诉数据库此事务为只读事务.数据化优化,会对
    性能有一定提升,所以只要是查询的方法,建议使用此数据.
    2.2 如果为 false(默认值),事务需要提交的事务.建议新增,删除,修
    改.
  3. propagation 控制事务传播行为.
    3.1 当一个具有事务控制的方法被另一个有事务控制的方法调用
    后,需要如何管理事务(新建事务?在事务中执行?把事务挂起?报异
    常?)
    3.2REQUIRED(默认值): 如果当前有事务,就在事务中执行,如果当
    前没有事务,新建一个事务.
    3.3 SUPPORTS:如果当前有事务就在事务中执行,如果当前没有事
    务,就在非事务状态下执行.
    3.4MANDATORY:必须在事务内部执行,如果当前有事务,就在事务
    中执行,如果没有事务,报错.
    3.5REQUIRES_NEW:必须在事务中执行,如果当前没有事务,新建事
    务,如果当前有事务,把当前事务挂起.
    3.6 NOT_SUPPORTED:必须在非事务下执行,如果当前没有事务,正
    常执行,如果当前有事务,把当前事务挂起.
    3.7NEVER:必须在非事务状态下执行,如果当前没有事务,正常执行,
    如果当前有事务,报错.
    3.8NESTED:必须在事务状态下执行.如果没有事务,新建事务,如果
    当前有事务,创建一个嵌套事务.
  4. isolation=”” 事务隔离级别
    4.1 在多线程或并发访问下如何保证访问到的数据具有完整性的.
    4.2 脏读:
    4.2.1 一个事务(A)读取到另一个事务(B)中未提交的数据,另一个事务中数据可能进行了改变,此时A事务读取的数据可能和数据库中数据是不一致的,此时认为数据是脏数据,读取脏数据过程叫做脏读.
    4.3 不可重复读:
    4.3.1 主要针对的是某行数据.(或行中某列)
    4.3.2 主要针对的操作是修改操作.
    4.3.3 两次读取在同一个事务内
    4.3.4 当事务A第一次读取事务后,事务B对事务A读取的数据进行修改,事务 A 中再次读取的数和之前读取的数据不一致,过程不可重复读.
    4.4 幻读:
    4.4.1 主要针对的操作是新增或删除
    4.4.2 两次事务的结果.
    4.4.3 事务A按照特定条件查询出结果,事务B新增了一条符合条件的数据.事务 A 中查询的数据和数据库中的数据不一致的,事务 A 好像出现了幻觉,这种情况称为幻读.
    4.5DEFAULT: 默认值,由底层数据库自动判断应该使用什么隔离界

    4.6READ_UNCOMMITTED: 可以读取未提交数据,可能出现脏读,不
    重复读,幻读.
    4.6.1 效率最高.
    4.7READ_COMMITTED:只能读取其他事务已提交数据.可以防止脏
    读,可能出现不可重复读和幻读.
    4.8 REPEATABLE_READ: 读取的数据被添加锁,防止其他事务修改
    此数据,可以防止不可重复读.脏读,可能出现幻读.
    4.9 SERIALIZABLE: 排队操作,对整个表添加锁.一个事务在操作数据时,另一个事务等待事务操作完成后才能操作这个表.
    4.9.1 最安全的
    4.9.2 效率最低的.
  5. rollback-for=”异常类型全限定路径”
    5.1 当出现什么异常时需要进行回滚
    5.2 建议:给定该属性值.
    5.2.1 手动抛异常一定要给该属性值.
  6. no-rollback-for=””
    6.1 当出现什么异常时不滚回事务.

Spring 中常用注解.

  1. @Component 创建类对象,相当于配置
  2. @Service 与@Component 功能相同.
    2.1 写在 ServiceImpl 类上.
  3. @Repository 与@Component 功能相同.
    3.1 写在数据访问层类上.
  4. @Controller 与@Component 功能相同.
    4.1 写在控制器类上.
  5. @Resource(不需要写对象的 get/set)
    5.1java 中的注解
    5.2 默认按照 byName 注入,如果没有名称对象,按照 byType 注入
    5.2.1 建议把对象名称和 spring 容器中对象名相同
  6. @Autowired(不需要写对象的 get/set)
    6.1spring 的注解
    6.2 默认按照 byType 注入.
  7. @Value() 获取 properties 文件中内容
  8. @Pointcut() 定义切点
  9. @Aspect() 定义切面类
  10. @Before() 前置通知
  11. @After 后置通知
  12. @AfterReturning 后置通知,必须切点正确执行
  13. @AfterThrowing 异常通知
  14. @Arround 环绕通知
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值