spring

最新推荐文章于 2024-11-01 15:24:56 发布

lyyibaobao

最新推荐文章于 2024-11-01 15:24:56 发布

阅读量112

点赞数

分类专栏： Spring框架文章标签： spring ioc aop

本文链接：https://blog.csdn.net/lyyibaobao/article/details/118052696

版权

Spring框架专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、Spring

1.1、简介

Spring是一个轻量级控制反转（loC）和面向切面（AOP）的容器框架

解决了企业级开发的复杂性，适用于任何java应用

2002，首次推出Spring框架的雏形：interface21 框架

Spirng框架即以interface21为框架为基础，经过重新设计，并不断丰富其内涵于2004年3月24日发布了1.0正式版解决企业企业应用开发的复杂性

Rod Johnson 创始人专业居然不是计算机而是音乐学非常牛逼

SSH： Strus2 + Spring + Hibernate
SSM： SpringMvc + Spring + Mybatis

官网：https://spring.io/projects/spring-framwork#overview

官方下载地址：https://repo.spring.io/release/org/springframework/spring

GitHub：https://gitsub.com/spring-projects/spring-framwork

1.2、优点

Spring是一个开源的免费的框架（容器）
Sprign是一个轻量级的、非入侵式的框架
控制反转（IOC），面向切面的编程（AOP）核心core
支持事务处理，对框架的整合支持

总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面(AOP)的框架

Spirng组成

核心容器（Spring Core）
核心容器提供spring框架的基本功能，SpirngyiBean的方式组织和管理java中的各个组件及其关系。Spirng使用BeanFactory使用控制反转（IOC）模式将应用的配置和依赖性与实际的应用程序代码分开

应用上下文（Spirng Context）
Spirng上下文是一个配置文件，想Spirng框架提供上下文信息，Spirng上下文包括企业服务，如JNDI、EJB、电子右键、国际化、校验和调度功能。

面向切面的编程（Spring AOP）
AOP(Aspect Oriented Programming)
通过配置管理特性，Spirng AOP 模块直接将米昂想方面的编程功能集成到了Spring框架中。所以，可以很容易地使Spirng框架管理的任何对象支持AOP。SpringAOP模块基于Spirng的应用程序中的对象提供了食物管理服务，通过Spring AOP 不用依赖EJB 组件，就可以将声明性事务管理集成到应用程序中

JDBC和DAO模块（Spring DAO）
　　JDBC、DAO的抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理，和不同数据库供应商所抛出的错误信息。异常层次结构简化了错误处理，并且极大的降低了需要编写的代码数量，比如打开和关闭链接。

对象实体映射（Spring ORM）
　　ORM(Object Relational Mapping)
　　Spring框架插入了若干个ORM框架，从而提供了ORM对象的关系工具，其中包括了Hibernate、JDO和 IBatis SQL Map等，所有这些都遵从Spring的通用事物和DAO异常层次结构。

Web模块（Spring Web）
　　Web上下文模块建立在应用程序上下文模块之上，为基于web的应用程序提供了上下文。所以Spring框架支持与Struts集成，web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

MVC模块（Spring Web MVC）
　MVC(Model View Controller)
　MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的。MVC容纳了大量视图技术，其中包括JSP、POI等，模型来有JavaBean来构成，存放于m当中，而视图是一个街口，负责实现模型，控制器表示逻辑代码，由c的事情。Spring框架的功能可以用在任何J2EE服务器当中，大多数功能也适用于不受管理的环境。Spring的核心要点就是支持不绑定到特定J2EE服务的可重用业务和数据的访问的对象，毫无疑问这样的对象可以在不同的J2EE环境，独立应用程序和测试环境之间重用。

Spirng Boot
一个快速开发的脚手架
基于SpirngBoot可以快速的开发的那个微服务
约定大于配置
Spirng Cloud
SpringCloud 是基于Spring Boot实现的

因为大多数公司都在使用Spirng Boot 进行快速开发，学习 SpirngBoot的前提，需要掌握Spirng 以及SpirngMVC 承上启下的作用

<dependencies>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-webmvc</artifactId>
  		<version>5.2.0.RELEASE</version>
  	</dependency>

IOC理论推导

1、UserDao 接口
2、UserDaoImpl 实现类
3、UserService 业务接口
4、UserServiceImpl 业务实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改代码

我们使用一个Set接口实现已经发生了革命性变化

private UserDao userDao;
//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao){
    this.userDao = userDao;
}

之前，程序主动创建对象控制权在程序员手上；使用set注入后，程序不再具有主动性，而是变成了被动接受对象

这种思想，在本质上解决了问题，程序员不用再去管理对象和创建了。系统的偶尔性大大减低，可以更加专注在业务的实现上这是IOC的原型

IOC本质

控制反转（IOC）是一种设计思想，DI（依赖注入）是实现Ioc的一种方法，也有人认为Ioc的另一种说法。没有Ioc的程序中，我们使用面向对象编程，对象的创建于对象的依赖关系完全硬编码在程序中，对象的创建有程序自己控制，控制反转后将对象转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了

Ioc是Spring的核心内容，使用多种方式完美实现了Ioc，可以使用Xml配置，也可以使用注解，新版本的Spirng也可以零配置实现Ioc

Spirng容器的初始化时先读取配置文件，根据配置文件或者数据创建与组织对象吧存入容器中，程序使用时在从Ioc容器中获取需要的对象

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而到达零配置的目的

控制反转是通过描述（XML或者注解）并通过第三方去产生或者获取特定对象的方式。在Spirng中实现反转的是Ioc容器，其实现方法是依赖注入（Dependency Injection，DI）

HelloSpring

IOC创建对象的方式

使用无参构造创建对象，默认
假设使用有参构造函数

有参构造

第一种下标赋值：

参数的类型：第二种通过类型创建

参数名：直接通过参数名来设置

总结：在配置文件加载的时候，容器中管理的对象就已经被实例化

Spirng配置说明

别名：

<!--别名  如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="userNew"></alias>

Bean的配置：

   <!--
        	id:bean的唯一标识符 ，也就是相当于我们学的对象名
			class： bean对象所对应的权限定名：包名+类名
			name：也是别名  而且name可以同时取多个别名
		-->
<bean id="userT" class="com.kaung.pojo.UserT" name="user2,u2 u3;u4"> <!--逗号和空格都行  -->
         		<property name="name" value="西部开源"></property>
</bean>

import

import，一般用于团队开发使用，他可以将多个配置文件，导入并合并为一个

多人开发，负责不同的类开发，多人可以复制多个不同的类开发，不同的需要注册在不同的bean中，我们可以利用import将所有的人的beans.xml合并为一个总的

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
        
        <!--   import可以合并为一个 -->
        <import resource="beans.xml"/>
        <import resource="beans2.xml"/>
        <import resource="beans3.xml"/>
        
 </beans>

直接使用总配置就可以了

POJO和javaBean的区别

POJO（Plain Ordinary Java Object）即普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO。

实际意义就是普通的JavaBeans（简单的实体类），特点就是支持业务逻辑的协助类。
POJO类的作用是方便程序员使用数据库中的数据表，对于程序员来说，可以很方便的将POJO类当作对象来进行使用，也可以方便的调用其get，set方法。
但不允许有业务方法,也不能携带有connection之类的方法，即不包含业务逻辑或持久逻辑等。

按着Sun公司的定义，JavaBean是一个可重复使用的软件组件。实际上JavaBean是一种Java类，通过封装属性和方法成为具有某种功能或者处理某个业务的对象，简称bean。
JavaBean 是一种JAVA语言写成的可重用组件。它的方法命名，构造及行为必须符合特定的约定：
这个类必须有一个公共的缺省构造函数。
这个类的属性使用getter和setter来访问，其他方法遵从标准命名规范。
这个类应是可序列化的。
因为这些要求主要是靠约定而不是靠实现接口，所以许多开发者把JavaBean看作遵从特定命名约定的POJO。

JavaBean的任务就是: “Write once, run anywhere, reuse everywhere”，即“一次性编写，任何地方执行，任何地方重用”。

JavaBean可分为两种：一种是有用户界面（UI，User Interface）的JavaBean；还有一种是没有用户界面，主要负责处理事务（如数据运算，操纵数据库）的JavaBean。JSP通常访问的是后一种JavaBean。

简而言之，当一个Pojo可序列化，有一个无参的构造函数，使用getter和setter方法来访问属性时，他就是一个JavaBean。

依赖注入

依赖注入：Set注入

依赖：bean对象的创建依赖于容器
注入：bean对象中的所有属性，由容器来注入

【环境搭建】

复杂类型

public class Address {
	private String address;
	public String getAddress() {
		return address;
	}
	public void SetAddress(String address) {
		this.address = address;
	}
}

真实测试对象

public class Student {
	private String name;
	private Address Address;
	private String[] books;
	private List<String> hobbys;
	private Map<String,String> card;
	private Set<String> games;
	private String wife;
	private Properties info;

3.测试类

public class MyTest {

	public static void main(String[] args) {
		ApplicationContext  context = new ClassPathXmlApplicationContext("beans.xml");
		Student student = (Student) context.getBean("student");
		System.out.println(student.toString());
	}

}

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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
        
        <bean id="address" class="com.kuang.pojo.Address">
        	<property name="address" value="西安"></property>
        </bean>
        
        <bean id="student" class="com.kuang.pojo.Student">
        <!-- 第一种普通值注入 value   -->
        	<property name="name" value="秦僵"></property>
        	<!--第二种注入 Bean注入 ref   -->
        	<property name="address" ref="address"></property>
        	
        	<!--数组  -->
        	<property name="books">
        		<array>
        			<value>红楼梦</value>
	        		<value>西游记</value>
	        		<value>水浒传</value>
	        		<value>三国演义</value>
        		</array>
        	</property>
        	<!-- List -->
        	<property name="hobbys">
        		<list>
        			<value>听歌</value>
        			<value>敲代码</value>
        			<value>看电影</value>
        		</list>       	
        	</property>
        	<!-- Map -->
        	<property name="card">
        		<map>
        			<entry key="身份证" value="123456789012345678"></entry>
        			<entry key="银行卡" value="123456799322533221"></entry>
        		</map>
        	</property>
        	<!-- Set -->
        	<property name="games">
        		<set>
        			<value>LOL</value>
        			<value>COC</value>
        			<value>BOB</value>
        		</set>
        	</property>
        	<!-- null -->
        	<property name="wife">
        		<null></null>
        	</property>
        	<!-- Properties 
        		key = value
        	 -->
        	<property name="info">
        		<props >
        			<prop key="driver">20200106</prop>
        			<prop key="url">男</prop>
        			<prop key="username">root</prop>
        			<prop key="password">123456</prop>
        		</props>
        	</property>
        </bean>     
</beans>

拓展方式注入

c命名和p命名空间注入

官方解释：

使用

<?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:p="http://www.springframework.org/schema/p"
     xmlns:c="http://www.springframework.org/schema/c"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">


	<!-- p空间注入，可以直接注入属性的值 ：property  要有无参构造器-->
	<bean id="user" class="com.kuang.pojo.User" p:name="秦僵" p:age="18"></bean>
	
	<!-- c空间注入  ，可以通过构造器注入 ：construct-args   要有参构造器 -->
	<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="狂神" ></bean>

</beans>

测试：

@Test
	public void test2() {
		ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
		User user = context.getBean("user2",User.class);//这个形式就不用强制转型了
		System.out.println(user);
	}

注意点：p命名和c命名控件不能直接使用，需要导入xml约束

 xmlns:p="http://www.springframework.org/schema/p"
 xmlns:c="http://www.springframework.org/schema/c"

Bean的作用域（范围）

单例模式（Spirng默认机制都是单列的）

<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="狂神" scope="singleton" ></bean>

原型模式：每次从容器中get的时候都会产生一个新对象 hashCode都不一样

<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

其余的request、session。application这些只能在web开发中使用到

Bean的自动装配

自动配置是Spring满足bean依赖一种方式
Spirng会在上下文中自动寻找，并自动给bean装配属性

在Spring中有三种装配的方式

在xml中显示位置
在java中显示配置
隐式的自动装配bean

测试

环境搭建：一个人有两个宠物

自动装配bean，有这几种方法

ByName自动装配

<bean id="cat" class="com.kuang.pojo.Cat"></bean>
<bean id="dog" class="com.kuang.pojo.Dog"></bean>
<!--
	  		byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid！
	  	  -->
	  	<bean id="people" class="com.kuang.pojo.People" autowire="byName">
	  		<property name="name" value="莫杰俊"></property>
	  	</bean>

ByType自动装配

<bean id="cat" class="com.kuang.pojo.Cat"></bean>
	  	<bean id="dog1111" class="com.kuang.pojo.Dog"></bean>
	  	
	  	<!--
	  		byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid！
	  	  	byType：会自动在容器上下文中查找，和自己对象属性的类型相同的bean
	  	  -->
	  	<bean id="people" class="com.kuang.pojo.People" autowire="byType">
	  		<property name="name" value="莫杰俊"></property>
	  	<!-- 进一步优化	<property name="dog" ref="dog"></property>
	  		<property name="cat" ref="cat"></property> -->
	  	</bean>

cat和dog或者dog111 这些id可以不要也能运行

byName的时候，需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
byType的时候，需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致

使用注解实现自动配置

jdk1.5支持注解，Spring2.5支持注解

要使用注解须知：

导入约束，context约束
配置注解支持：context:annotation-config/

<?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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop 
        https://www.springframework.org/schema/aop/spring-aop.xsd">
	<!--注入注解的支持-->
    <context:annotation-config/>
</beans>

@Autowired

直接在属性上使用即可，也可以在set方式使用

使用Autowired我们可以不用编写set方法了，前提是你自动装配的属性在IOC（Spring）容器中存在，且符合名字byName

科普：

@Nullable 字段标记这个注解，说明字段可以为null

测试代码

	@Autowired  //这个注解可以不用写set方法
	private Cat cat;
	//如果显示定义了Autowired的required属性为false 说明这个对象可以为null，否则不允许为空
	@Autowired(required = false)
	private Dog dog;
	private String name;

@Qualifier(value=“xxx”)

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们额可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入

public class People {
	
	@Autowired  //这个注解可以不用写set方法
	@Qualifier(value="cat111")
	private Cat cat;
	//	@Autowired(required = false如果显示定义了Autowired的required属性为false 说明这个对象可以为null，否则不允许为空
	@Autowired
	@Qualifier(value="dog222")
	private Dog dog;
	private String name;
}

@Resource

结合byName和ByType ，当前者无法找到会根据后者找，如果前者能找到就把直接用前者，如果两个都不能找到就会报错

小结：

@Resource 和@Autowired的区别：

@Component：组件；放在类上，说明这个类被Spirng管理了，就是bean

使用注解开发

bean
属性如何注入

//等价于<bean id="user" class="com.kuang.pojo.User"/>
// @Component  组件
@Component
public class User {
	//public String name ="mojiejun";
	//@Value相当于<property name="name" value="mojiejun"/>
	//@Value("mojiejun1") 
	public String name ;
	@Value("mojiejun2")
	public void setName(String name) {
		this.name = name;
	}
	
}

衍生的注解

@Component有几个注解，我们在web开发中，就会按照MVC三层架构分层
- dao【@Repository】
- service【@Service】
- controller【@Controller】
这四个功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
自动装配配置

作用域

//等价于<bean id="user" class="com.kuang.pojo.User"/>
// @Component  组件
@Component
//单例模式singleton  prototype 原型模式
@Scope("singleton")
public class User {
	//public String name ="mojiejun";
	//@Value相当于<property name="name" value="mojiejun"/>
	//@Value("mojiejun1") 
	public String name ;
	@Value("mojiejun2")
	public void setName(String name) {
		this.name = name;
	}	
}

部分注解说明

小结

xml与注解：

xml更加万能，适用于任何场合，维护简单方便
注解不是自己类使用不了维护相对复杂

xml与注解最佳的实践

xml用来管理bean
注解负责完成属性的注入
在使用的过程中需要注意一个问题，必粗要让注解生效，就要开启注解的支持

<!--  开启注解的支持-->
        <context:annotation-config/>       
        <!--指定要扫描的包，这个包下的注解就会生效  -->
	<context:component-scan base-package="com.kuang"></context:component-scan>
	<context:annotation-config></context:annotation-config>

使用Java的方式配置Spring

我们现在完全不使用配置Spring的xml配置，全权交给java来做

javaConfig是Spring的一个子项目，在Spring之后，成为了一个核心功能

实体类

//这里这个注解的意思，就是说明这个类被Spring接管了 注册到了容器中
@Component
public class User {
	private String name;

	public String getName() {
		return name;
	}
	@Value("mojiejun") //属性注入值
	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "User [name=" + name + "]";
	}	
}

配置文件

@Configuration //这个也会被Spring容器注册倒容器中，因为他本来就是一个@Conponent
// @Configuration代表这是一个配置类 就和我们之前看的beans.xml是一样的
@ComponentScan("com.kuang.pojo")
@Import(KuangConfig2.class)
public class kuangConfig {
	//注册一个bean  就相当于我们之前写的一个bean标签
	//这个方法的名字，就相当于bean标签中的id属性
	//这个方法的返回值，就相当于bean标签中的class属性
	@Bean
	public User user() {		
		return new User();//就是返回要注入到bean的对象
		
	}
}

测试类

public class MyTest {
	public static void main(String[] args) {		
	//完全使用了配置类方式去做，我们就只能通过AnnntationConfig上下文获取容器，
		//通过配置类的class对象加载
	ApplicationContext context = new AnnotationConfigApplicationContext(kuangConfig.class);
	User getUser = context.getBean("user",User.class);
	System.out.println(getUser.getName());
	}
}

属于纯java的配置方式，在SpirngBoot中随处可见

代理模式

为什么学习代理模式？因为这就是SpringAOP的底层【SpirngAOP 和 SpirngMVC】

代理是分类：

静态代理
动态代理

静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色就是我要去结婚会场和安排全部交给代理人，我就是那个被代理的角色
代理角色：代理真实角色后，我们一般会做一些附属操作，比如我结婚他去帮我收钱

代理步骤：

接口

//租房接口
public interface Rent {	
	public void rent();
}

真实角色

//房东
public class Host implements Rent {
	public void rent() {
		System.out.println("房东要出租房子了！");	
	}	 
}

代理角色

//用了继承房东的话有局限性
public class Proxy {
	//先用组合的方式少用继承 直接把房东拿进来就可以了
	private Host host;	
	public Proxy() {		
	}
	public Proxy(Host host) {
		this.host = host;
	}
	public void rent() {
		seeHouse();
		host.rent();
		hetong();
		fare();
	}	
	//看房  中介帮房东做了一件事情 
	public  void seeHouse() {
		System.out.println("中介带你看房");
	}
	//收中介费
	public void fare() {
		System.out.println("收中介费");
	}
	//签租赁合同
	public void hetong() {
		System.out.println("签租赁合同");
	}
}

客户端访问代理角色

public class Client {
	public static void main(String[] args) {
		//房东要租房子
		Host host = new Host();
		//中介帮你租房子，但是呢，代理角色（中介）一般会有一些附属操作
		//来一个代理 代理房东  给完代理之后他就代表房东
		Proxy proxy = new Proxy(host);
		//你不用面对房东  ，直接找中介租房
		//本质调用的是 host.rent(); 只是多了一层关系
		proxy.rent();
	}
	//Host必须存在，不然你Proxy代理谁，独享都不能创建，也就不能做其他方面的增强了
	//本身就是为了在不改变Host类	的基础上，使用Proxy类对Hst进行了代理与功能增强
}

代理模式的好处：

可以是真实角色的操作更加纯粹，不用去关注一些公共的业务
公共也就交给了代理角色，实现了业务的分工
公共业务发生扩展的时候，方便集中管理

缺点：

一个真实角色就会产生一个代理角色；代码量会翻倍，开发效率会变低

加深理解

代码对应08-demo02 （aop）

动态代理

动态代理和静态代理角色一样
动态代理的道理类是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口 ----JDK 动态代理【我们在这里使用】
- 基于类：cglib
- java字节码实现：javasist
- 底层是基于反射机制

需要了解两个类： Proxy（代理）、InvocationHandler（调用处理（Handler）程序）

InvocationHandler是有代理实例的，调用处理程序实例实现的接口

每个代理实例都有一个关联的调用程序，当在代理程序上调用方法时，方法调用将被编码分派到其他调用处理程序的invoke方法

Proxy：提供了创建静态方法和实例的静态方法，他也是有这些方法创建的所有动态代理类的超类

proxy是真实对象的真实代理对象，invoke方法可以返回调用代理对象方法的返回结果，也可以返回对象的真实代理对象。

动态代理的好处：

可以是真实角色的操作更加纯粹，不用去关注一些公共的业务
公共也就交给了代理角色，实现了业务的分工
公共业务发生扩展的时候，方便集中管理
一个动态代理类代理的是一个接口，一般就是对应的一类业务
一个动态代理类可以代理多个类，只要是实现了同一个接口

Proxy类就是用来创建一个代理对象的类，它提供了很多方法，但是我们最常用的是newProxyInstance方法。

  public static Object newProxyInstance(ClassLoader loader, 
                                            Class<?>[] interfaces, 
                                            InvocationHandler h)

loader：一个classloader对象，定义了由哪个classloader对象对生成的代理类进行加载
interfaces：一个interface对象数组，表示我们将要给我们的代理对象提供一组什么样的接口，如果我们提供了这样一个接口对象数组，那么也就是声明了代理类实现了这些接口，代理类就可以调用接口中声明的所有方法。
h：一个InvocationHandler对象，表示的是当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象上，并最终由其调用。

封装好的一个代理

package demo04;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//代理调用处理程序 我们会用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler{
	
	//被代理的接口  下边的需要传的代理接口
	private Object target;	

	public void setTarget(Object target) {
		this.target = target;
	}

	//生成得到代理类 这一个方法是固定的套路换汤不换药
	 public Object  getProxy() {
		 //传三个参数  第一个参数是类的加载器  第二个拿到代理的接口  第三个就是实现他自己的本身
		return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}	
	//处理代理实例，并返回结果 
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		
		//动态代理的本质，就是使用反射机制实现
		Object result = method.invoke(target, args);
		log(method.getName());//通过method反射对象得到他的名字 变成灵活的了不死了
		return result;
		//反射包下的method   method反射包下有一个方法invoke() invoke 执行上面rent接口的方法  args给它的参数
		//执行完之后返回一个结果result
	}	
	public void log(String msg) {
		System.out.println("执行了"+msg+"方法");
	}

测试：

public class Client {
	public static void main(String[] args) {
		//真实角色
		UserServiceImpl userService = new UserServiceImpl();
		//代理角色 不存在
		ProxyInvocationHandler pih = new ProxyInvocationHandler();		
		pih.setTarget(userService);//设置要代理的对象		
		//动态生成代理类
		UserService proxy = (UserService) pih.getProxy();
		proxy.query();
	}
}

关于动态代理用到的反射机制

getClass

this.getClass（）.getClassLoader（）：

这个参数是指当前类由那个类加载器进行加载

AOP

什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译的方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编译的一种衍生泛型，利用AOP可以对业务逻辑的各种部分进行隔离，从而使得业务各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率

aop.ng

AOP在Spring中的作用

提供声明式事务；允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或者功能，即是，我们的业务逻辑无关的但是我们需要关注的部分，就是横切关注点，如日志，安全，缓存，事物等等…
切面（ASPECT）：横切关注点，被模块化的特殊对象，他是一个类
通知（Adivce）：切面必须要完成的工作，即，他是类中的方法
目标（Target）：被通知的对象
代理（Proxy）：向目标对象应用通知之后创建的对象
切入点（PointCut）：切面通知执行的“地点”的定义
连接点（JoinPoint）：与切入点匹配的执行点

使用Spring实现AOP

AOP实现的三种·方式

方式一：使用Spring的API接口【主要SpringAPI接口实现】

方式二：自定义来实现AOP【主要切面定义】

方式三：使用注解实现！

方式一使用Spring的API接口【主要SpringAPI接口实现】

导入依赖

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

配置xml

?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    
        <!--注册bean  -->
        <bean id="userService" class="service.UserServiceImpl"></bean>
        <bean id="log" class="log.Log"></bean>
        <bean id="afterLog" class="log.AfterLog"></bean>             
          <!--方式一：使用原生的Spring API 接口  -->
        <!-- 配置aop  需要导入aop的约束 -->
        <aop:config>
        	<!--切入点  expression:表达式    execution(要执行的位置 *（修饰词） *（返回值） *（类名） *（方法名）*（参数） )  *代表任意东西-->
        	<aop:pointcut id="pointcut" 
        	expression="execution(* service.UserServiceImpl.*(..))"/>
        	<!-- .*表示这个类下的所有方法 (..) 代表任意参数   -->
        	<!--执行环绕增加  -->
        	<!-- advisor 环绕的意思；这句话的意思是 我们吧log这个类 切入到方法上面去 -->
        	<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        	<!--afterLog类切入到pointcut  -->
        	<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
        </aop:config>       
 </beans>

代理接口

public interface UserService {
	public void add();
	public void delete();
	public void update();
	public void select();
}

实现代理接口类

public class UserServiceImpl implements UserService{
	public void add() {
		System.out.println("增加了一个用户");		
	}
	public void delete() {
		System.out.println("删除了一个用户");		
	}
	public void update() {
		System.out.println("修改了一个用户");	
	}
	public void select() {
		System.out.println("查寻了一个用户");		
	}
}

SpringAOP 的方法Advice 前置通知（ MethodBeforeAdvice）实现日志功能切面切入

public class Log implements MethodBeforeAdvice {	
	//method :要执行目标对象的方法 
	//object[] args ：参数
	//target：目标对象
	public void before(Method method, Object[] args, Object target) throws Throwable {		System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
	}
}

SpringAOP中的方法Advice 后置通知（AfterReturningAdvice）实现日志功能且面切入

public class AfterLog implements AfterReturningAdvice {	
	//returnValue 返回值
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);		
	}
}

测试类

public class MyTest {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");	
		//动态代理代理的是接口  不能是具体的实现类
		UserService  userService = (UserService) context.getBean("userService");
		// 错误UserServiceImpl  userService = context.getBean("userService",UserServiceImpl.class);  这个是具体的实现类了
		userService.select();
	}
}

AOP实现方式二：切面

public class DiyPointCut {
    public void before(){
        System.out.pringtln("========执行方法前=====")
    }
    public void after(){
        System.out.println("========执行方法后======")
    }
}

?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!--方式二 ： 自定义类-->
    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>
    
    <aop:config>
        <!--自定义切面   ref要应用的类-->
        <aop:aspect ref="diy">
        	<!--切入点-->
            	<aop:poincut id="point" expression="execution(* com.kaung.service.UserServiceImpl.*(..))"/>
            <!--通知  把DiyPointCut的名字绑定到method里面-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

public class MyTest(){
    public static void main(String [] ,args){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理的是接口，注意点
        UserService userService =(UserService)context.getBean("userService");
        ///userService.add()/update()...
        userService.select();
    }
}

方式三：注解的方式@Aspect

@Aspect//标注这个类是一个切面
public class AnnotationPointCut(){
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.pringtln("===执行方法前===")
    }
    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void After(){
        System.out.pringtln("===执行方法后===")
    }
    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理的切入的点
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void Around(PocessdingJoinPoint jp){
        System.out.pringtln("===环绕前===")
        
        Signature signature = jp.getSignature();//获得签名
        System.out.println("signature",signature);
            //执行方法
        Object proceed = jp.proceed();
        System.out.println("===环绕后====");
        System.out.println(proceed);
    }
}

?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <bean id="userService" class="com.kaung.service.UserServiceImpl"/>
    <bean id="log" class="com.kaung.log.Log"/>
    <bean id="afterLog" class="com.kaung.log.AfterLog"/>
    <!--方式三-->
    <bean id="annotationPointCut" class="com.kaung.diy.AnnotationPointCut"/>
    <!--开启注解支持-->
   <aop:aspectj-autoproxy/>
</beans>

测试结果

整合MyBatis

步骤：

导入jar包
1. junit
2. mybatis
3. mysql数据库
4. Spirng相关的
5. aop植入
6. mybatis-spring【new】
2.编写配置文件

3.测试

回忆mybatis
1. 编写实体类
2. 编写核心配置
3. 编写接口
4. 编写Mapper.xml
5. 测试

MyBatis-Spring

整合方式一

xml文件配置

.sqlSessionFactory
sqlSessionTemplate
需要给接口实现类【set一个方法】
将自己写的实现类，注入到Spring中
测试使用即可

整合方式二

声明式事物

事物ACID原则：

原子性
一致性
隔离性
- 多个业务可能操作同一个资源，防止数据损坏
持久性
- 事物一旦提交，无论是吴系统发生什么问题，结果都不会被影响，被持久化的写到存储器中

Spirng中的事务管理

声明式事务：AOP
编程时事物：需要在代码中进行事物管理

配置的作用：

如果不配置事务，可能存在的数据提交不一致的情况下
如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置
W-1624080640309)]

整合MyBatis

步骤：

导入jar包
1. junit
2. mybatis
3. mysql数据库
4. Spirng相关的
5. aop植入
6. mybatis-spring【new】
2.编写配置文件

3.测试

回忆mybatis
1. 编写实体类
2. 编写核心配置
3. 编写接口
4. 编写Mapper.xml
5. 测试