spring的DI，IOP，AOC，Spring的简单介绍

最新推荐文章于 2022-09-29 13:26:27 发布

Syntactic_suger

最新推荐文章于 2022-09-29 13:26:27 发布

阅读量3.7k

点赞数 1

本文链接：https://blog.csdn.net/Syntactic_tang/article/details/102929907

版权

回顾:

1. mybatis的性能优化.
	一级缓存.
		减轻数据库的压力.
		默认开启.
		一级缓存是线程级别,sqlSession,缓存数据的map就放在sqlSession中的PerpetualCache的中.
		一级缓存是通过SimpleExecutor去执行.
		在去数据库查询之前,先去一级缓存的map中尝试获取数据mapperId + mapper全路径 + sql + 占位符的数据 + 环境名作为map的key去获取数据.
		如果获取不到执行queryFromDataBase去数据库查询,查询到之后,再放到一级缓存中.
			
	二级缓存.
		减轻数据库的压力.
		开启二级缓存. -> 全局开关默认开启 -> 开启某个映射文件的开关(默认关闭) -> 每个<select>标签还有一个开关useCache属性(默认开启).
		二级缓存是工厂级别.二级缓存的map放在了SqlSessionFactory的cache对象中的PerpetualCache中.
		二级缓存是用过CachingExecutor去执行.
		调用SimpleExecutor之前,先通过CachingExecutor去二级缓存中查询数据,会经历一个cache链. synchronizedCache -> LoggingCache -> 序列化Cache -> LruCache -> PerpetualCache. 如果没有查询到二级缓存中的数据 -> 调用SimpleExecutor去执行 -> 去数据库查询 -> 在提交事务之后,会将查询到的数据存储在二级缓存中.
		
	懒加载.

2. spring介绍.
	spring的两个核心组件.
		IOC | DI	->		解耦.
		AOP			->		面向切面编程.
		controller  ->		springmvc(对servlet的封装)
		service	    ->		声明式事务.(彻底的解决了单体项目的事务问题)
		dao         -> 		最开始提供了jdbcTemplate | 后期提出了spring的data系列
		第三方框架的粘合剂	->	后期所有第三方框架都要与spring整合.
		低侵入式	 ->  	 EJB对比.
		.....

3. spring的IOC介绍.
	IOC是以为mattson提出的一个思想 -> 降低对象之间的耦合性.
	DI是马丁大神在观摩了IOC思想后,提出了一个更准确的名字.
	
	IOC	控制反转.
	DI	依赖注入.
		将创建对象的权利反转给IOC容器,由IOC容器管理对象之间的依赖关系.
	
    spring的IOC实现原理.
    	反射 -> 创建对象.
    	SAX -> 解析xml文件的.			(SAX,dom4j) -> document.
    	工厂模式 -> IOC容器就是一个大工厂.
    	单例模式 -> IOC容器构建的对象默认是单例的.
		责任链模式 
		代理模式
		装饰者模式
		......
	
4. spring的IOC的入门.
	1. 创建项目.
	2. 导入依赖.
		beans , core , context , expression language , commons-logging
		junit
	3. 准备POJO类.
	4. 编写spring的配置文件.
		成功的导入依赖.
		new -> xml -> spring Config (mybatis -> DTD   spring -> Schema)
		
		1. 编写bean标签.
			<bean id="当前实例在IOC工厂中的唯一标识" class="类的全路径" />
			
	5. 测试.
		(BeanFactory)
    	ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:配置文件路径");
    	Object obj = ac.getBean("实例标识");
		
5. bean标签属性
	id:						唯一标识.
	class: 					类的全路径.
	name:					唯一标识.
	scope:					作用域: singleton,prototype,request,session,global-session
	lazy-init:				懒加载.(只针对单例有效,默认为false). 默认用空间换时间.
												  使用懒加载: 用时间换空间.
	depends-on:				在初始化当前实例前,先去初始化其他实例. depends-on="实例1,实例2...."
	init-method:			创建对象后,执行init初始化方法.
	destroy-method:			对象销毁后,执行destroy销毁方法.
	
--------------------------------------------------------------------------------------	
	
	factory-bean:			
	factory-method:
		静态工厂.
			提供静态方法.
				<bean id="" class="" factory-method="" />
		实例工厂.
			提供非静态方法.
				<bean id="" class="" />
				<bean id="" factory-bean="" factory-method="" />

一. spring的DI.(重要)

1. set方式注入. (重要)

<bean>
	<property name="属性名 | set方法去掉set,第一个字母小写"  value="String|基本数据类型" />
	<property name="属性名"  value="值" />
	<property name="属性名"  value="值" />
	<property name="属性名"  value="值" />
</bean>

2. 有参构造注入. (重要)

<bean id="user" class="com.qf.entity.User" >
<!--        1. 有参构造注入-->
    <constructor-arg name="构造方法的参数名" value="值" index="索引位置" type="数据类型" />
    <!-- index和type可以省略不写. -->
    <!-- 非常依赖有参构造方法的重载. -->
</bean>

3. p命名空间注入. (一般重要)

set注入的简写形式. 本质还是set注入.
1. 导入p命名空间的约束.
<xmlns:p="http://www.springframework.org/schema/p">
2. 给bean添加属性 p:属性名 赋值.
<bean id="user" class="com.qf.entity.User" p:name="王五" p:age="25" />

4. 复杂类型属性注入. (重要)

1. Array.
2. List.
3. Set.
4. Map.
5. Properties.

5. 自定义类型注入. (最重要)

<!--    自定义|POJO类型注入-->
    <bean id="role" class="com.qf.entity.Role" ></bean>


    <bean id="user" class="com.qf.entity.User">
<!--        使用set注入,将role的实例注入到user中的role属性里-->
        <property name="role" ref="role" />
    </bean>

二. 完成三层的创建和注入.(IOC+DI的练习)

1. 准备好
	controller类.
	service接口. service实现类.
	mapper接口. mapper实现类.
	
2. 在类中引用好依赖关系.	
	controller类 引用 service接口;
	service实现类  引用 mapper接口;
	提供set方法.使用set注入方式.
	
3. 编写spring的配置文件.
<!--    1. controller-->
    <bean id="userController" class="com.qf.controller.UserController">
<!--        set方式注入UserServiceImpl的实例-->
        <property name="userService" ref="userService" />
    </bean>

<!--    2. service-->
    <bean id="userService" class="com.qf.service.impl.UserServiceImpl">
<!--        set方式注入UserMapperImpl的实例-->
        <property name="userMapper" ref="userMapper" />
    </bean>

<!--    3. dao-->
    <bean id="userMapper" class="com.qf.mapper.impl.UserMapperImpl">

    </bean>

三. 使用注解的方式完成IOC和DI.(重要)

1. 创建项目.

2. 导入依赖.

注解实现IOC和DI,spring的依赖需要6个.
	beans , core , context , expression language , commons-logging , aop
	junit
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

3. 准备三层(三个类和两个接口).

....

4. 编写配置文件.

<!-- 开启注解扫描 -->
<?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: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/context
                          http://www.springframework.org/schema/context/spring-context.xsd">


<!--    开启注解扫描 com.qf.controller,com.qf.service,com.qf.mapper-->
    <context:component-scan base-package="com.qf.controller,com.qf.service,com.qf.mapper" />


</beans>

5. 添加注解.

IOC注解:
	(添加在类上) <bean id="默认类名的首字母小写"  class="" />
	@Controller			controller层
	@Service			service层
	@Repository			dao层
	@Component			POJO类
	
DI注解:
	@Autowired (spring提供的)
		// 自动类型注入.
		如果IOC容器中有多个可注入的bean实例单独使用注解区分.
		@Qualifier(value = "唯一标识")   // 扣了faier
		
	@Resource  (javaEE规范提供的)
		默认情况下,@Resource会先根据属性名选择根据名称注入指定对象实例.
				 			     如果IOC容器中没有,采用自动类型注入.
		如果给Resource添加了name属性,只根据名称注入.
		如果给Resource添加了type属性,只根据类型注入.
		如果给Resource同时添加了name和type属性,去IOC容器中找name和type同时符合的实例.

6. 测试.

@Test
public void threeC(){

    ApplicationContext ac = new
        ClassPathXmlApplicationContext("classpath:applicationContext.xml");


    UserController userController = (UserController) ac.getBean("userController");

    userController.save();
}

7. IOC注解实现详情.

@Scope("singleton | prototype | request | session | global-session")
@Lazy  // 懒加载(可以添加在类上,也可以添加在属性)
@DependsOn({"userServiceImpl","userMapperImpl"}) // 初始化前先初始化value
@PostConstruct  // init-method
@PreDestroy     // destroy-method

// 四. spring的循环依赖.(后面).

五. spring整合junit测试代码.(重要)

1. 导入依赖.

beans , core , context , expression language , commons-logging , aop
junit4, spring-test.
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>4.3.8.RELEASE</version>
</dependency>

2. 创建测试类,添加注解.

@Runwith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:配置文件路径",""})
//----------------------------------------------------------------
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class UserControllerTest {

    @Test
    public void save() {
    }
}

3. 可以直接使用DI注解,注入测试的对象.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class UserControllerTest {

    @Autowired
    private UserController userController;

    @Test
    public void save() {
        userController.save();
    }
}

六. spring的AOP介绍.

1. 什么是spring的AOP.

AOP即面向切面编程,将程序中共性的代码横向的抽取出来,在改变源代码前提下,将共性的内容动态的织入到指定的位置.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FAuE4wlu-1573006440241)(img/1569659309481.png)]

2. AOP的由来.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kd1quGYJ-1573006440242)(img/1569659345540.png)]

3. 什么动态代理.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QQMpR2Xn-1573006440243)(img/1569659415572.png)]

4. AOP的实现原理.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aTF4j52J-1573006440245)(img/1569659491530.png)]

七. AOP的相关术语.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AosaxX7M-1573006440246)(img/1569660370365.png)]

八. spring的AOP入门.

1. 创建项目.

…

2. 导入依赖.

<dependencies>
    <!--    spring核心5个依赖. + spring-aop-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <!--    spring的aop依赖.   aop联盟(4.3中木有了), aspectJ , spring-aspects , -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <!--    spring-test-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <!--    junit4-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

3. 编写连接点,增强.

...

4. 编些配置文件.(选择切入点,配置切面)

...

5. 测试.

..

factId>spring-test
4.3.8.RELEASE

junit
junit
4.12


### 3. 编写连接点,增强.

…




### 4. 编些配置文件.(选择切入点,配置切面)

…




### 5. 测试.

…

Syntactic_suger

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
3
评论
spring的DI，IOP，AOC，Spring的简单介绍

回顾:1. mybatis的性能优化. 一级缓存. 减轻数据库的压力. 默认开启. 一级缓存是线程级别,sqlSession,缓存数据的map就放在sqlSession中的PerpetualCache的中. 一级缓存是通过SimpleExecutor去执行. 在去数据库查询之前,先去一级缓存的map中尝试获取数据mapperId + mapper全路径 + sql + 占位...
复制链接

扫一扫