SSM框架速成2——Spring5速成总结
还是那个意思，速成只是为了迅速做个项目提高动手能力，最后还是要回归把所有框架的精髓原理弄清楚！
只是参考，每个人都会遇到不同的问题，根本的东西是万万离不开官方文档的，这里分享一下Spring5的中文官方文档：
Spring官方文档
目录
- 第一个Spring工程
- 控制反转IOC
- Spring配置说明
- DI依赖注入——set方式注入
- 拓展方式注入-c命名和p命名空间注入
- Bean的作用域
- Bean的自动装配
- 使用注解开发
- 使用java的方式配置Spring（必会！为springboot打好预防针）
- 代理模式
- 动态代理详解
- AOP
第一个Spring工程
1、新建一个普通的maven项目，在pom.xml中导入jar包
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.1.RELEASE</version>
</dependency>
2、在main-java文件夹下新建packetage：com.wang.pojo，并在pojo下新建实体类Hello
Hello类的内容：
package com.wxj.pojo;
public class Hello {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
注意：这里的重点是set方法，set可以给接下来的beans.xml文件注入str！
3、配置
（1）在resources下新建beans.xml，整个文件的跟标签是beans。使用Spring来创建对象，在Spring中的这些对象都称为bean。
而在beans标签下的所有bean标签，有如下重要参数：
①id：变量名
②class：对象的绝对路径
③property：相当于给对象中的一个属性设置一个值
而在property中也有一些参数的说明，具体的就不多说，看后面有关于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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="hello" class="com.wxj.pojo.Hello">
<!--
ref：引用spring容器中创建好的对象
value：具体的值即基本数据类型
-->
<property name="str" value="Spring"/>
</bean>
</beans>
4、test写一个实现类
import com.wxj.pojo.Hello;
import javafx.beans.property.ObjectProperty;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args){
//获取Spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在spring中管理了，要使用时，直接去里面取出来即可
Object hello=(Hello)context.getBean("hello");
System.out.println(hello.toString());
}
}
控制反转IOC
1、直接新建一个spring-ioc的module，目录结构如下：
其中dao包下的UserDao表示业务接口，而UserDaoImpl、UserDaoMysqlImpl、UserDaoOracleImpl分别表示UserDao业务的实现类。
而service包下的UserService表示服务接口，而UserServiceImpl表示服务实现类。
各个类和接口的内容如下：
（1）UserDao接口：
package com.wang.dao;
public interface UserDao {
void getUser();
}
（2）UserDaoImpl实现类：
package com.wang.dao;
public class UserDaoImpl implements UserDao{
@Override
public void getUser() {
System.out.println("默认获取用户的数据");
}
}
（3）UserDaoMysqlImpl实现类：
package com.wang.dao;
public class UserDaoMysqlImpl implements UserDao{
@Override
public void getUser() {
System.out.println("Mysql获取用户数据！");
}
}
（4）UserDaoOracleImpl实现类：
package com.wang.dao;
public class UserDaoOracleImpl implements UserDao{
@Override
public void getUser() {
System.out.println("Oracle获取用户数据！");
}
}
（5）UserService接口：
package com.wang.service;
public interface UserService {
void getUser();
}
（6）UserServiceImpl实现类：
package com.wang.service;
import com.wang.dao.UserDao;
import com.wang.dao.UserDaoImpl;
public class UserServiceImpl implements UserService{
private UserDao userDao=new UserDaoImpl();
@Override
public void getUser() {
userDao.getUser();
}
//public void setUserDao(UserDao userDao) {
//this.userDao=userDao;
//}
}
（7）MyTest内容：
import com.wang.dao.UserDaoImpl;
import com.wang.service.UserService;
import com.wang.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
//获取ApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//容器在手，需要什么就直接get什么
UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
userServiceImpl.getUser();
}
}
来思考一下如果没有Spring，我们如何实现这个业务：
main函数调用UserServiceImpl的实现类来取到UserDao实例化对象，并且通过重写方法getUser来输出一个值。像如上代码那样，我们最终输出的结果就是“默认获取用户的数据”，而如果用户需要的业务是MySQL或者Oracle数据库，我们就需要手动修改代码，在UserServiceImpl中定义userDao中new出来的对象分别改为UserDaoMysqlImpl或UserDaoOracleImpl。
思考：这是一个好的工程吗？
每次用户提出一个需求，身为程序员的我们居然要次次修改业务逻辑实现类的代码，这并不方便。
这就提出了一个概念：主动。
也就是说，每次我们都在代码中主动的引出对象，来应对用户提出的每次需求。这就是主动。
引入：控制反转IOC
在beans.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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="mysqlImpl" class="com.wang.dao.UserDaoMysqlImpl"/>
<bean id="oracleImpl" class="com.wang.dao.UserDaoOracleImpl"/>
<bean id="UserServiceImpl" class="com.wang.service.UserServiceImpl">
<!--
ref：引用Spring容器中创建好的对象
value：具体的值，即基本数据类型
-->
<property name="userDao" ref="mysqlImpl"/>
</bean>
</beans>
如上，我们把Dao的方法的实现装到了容器中，取一个合适的变量名，并且定位好绝对路径。接着装上服务实现的方法，在这里引入property来设置到底是什么服务，如上代码是会输出MySQL的方法所对应的输出，而如果用户要Oracle的呢？直接让他修改beans.xml的ref属性就好了鸭！这里毕竟只是个小小的原型，很多很多的业务处理的时候，我们不可能让用户一个个看着底层代码搞吧？但是让用户改一个bean中的属性还是很可取的！
总结：
（1）控制：传统应用程序的对象是由程序本身控制创建的，使用spring后，对象是由spring创建的
（2）反转：程序本身不创建对象（原先java是new一个对象），而变成被动的接收对象
依赖注入：利用set方法来进行注入的，即删除str的set方法以后无法成功（beans的name报错）
IOC是一种编程思想，由主动的编程变成被动的接收对象
IOC：对象由spring来创建，管理，装配
Spring配置说明
1、新建一个module，目录结构如下：
内容分别为：
（1）User类：
package com.wang.pojo;
public class User {
private String name;
public User(String name){
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name="+name);
}
}
（2）beans.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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
id：bean的唯一标识符，相当于对象名
class：bean对象所对应的全限定名（包名+类名）
name：标识符的别名，而且比alias更高级，可以同时取多个别名，如：
<bean id="user" class="com.wang.pojo.User" name="user,u1,u2">
这种情况下java可以通过取"u1"或"u2"来取得这个容器对应的类
-->
<!-- <!–第一种方式：下标赋值–>-->
<!-- <bean id="user" class="com.wang.pojo.User">-->
<!-- <constructor-arg index="0" value="俊哥"/>-->
<!-- </bean>-->
<!-- <!–第二种方式，通过类型创建，不建议使用。比如有两个参数类型都是一样的呢？–>-->
<!-- <bean id="user" class="com.wang.pojo.User">-->
<!-- <constructor-arg type="java.lang.String" value="俊哥2"/>-->
<!-- </bean>-->
<!--方式三：直接通过方式名来设置-->
<bean id="user" class="com.wang.pojo.User" name="user2">
<constructor-arg name="name" value="俊哥3"/>
</bean>
</beans>
（3）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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--import通常用于团队开发使用，可以将多个配置文件，导入合并为一个-->
<import resource="beans.xml"/>
</beans>
（4）MyTest类：
import com.wang.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
//在配置文件加载的时候，容器中管理的对象就已经初始化了
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.show();
}
}
id：bean的唯一标识符，相当于对象名
class：bean对象所对应的全限定名（包名+类名）
name：标识符的别名，而且比alias更高级，可以同时取多个别名，如：
<bean id="user" class="com.wang.pojo.User" name="user,u1,u2">
这种情况下java可以通过取"u1"或"u2"来取得这个容器对应的类
介绍一下通过bean设置来使得MyTest类直接取得容器内的对象。
方法一：下标赋值
<bean id="user" class="com.wang.pojo.User">
<constructor-arg index="0" value="俊哥">
</bean>
方法二：通过类型来创建，这种方法是不建议使用的。毕竟当有两个或多个参数类型都一样的话，就会起冲突
<bean id="user" class="com.wang.pojo.User">
<constructor-arg type="java.lang.String" value="俊哥2">
</bean>
方法三：直接通过方式名来设置（name的值为实体类中set后面跟的单词的首字母小写）
<bean>
<constructor-arg name="name" value="俊哥3">
</bean>
DI依赖注入——set方式注入
依赖：bean对象的创建依赖于容器
注入：bean对象中的所有属性，由容器来注入
这里主要给出注入对象的方法，直接通过样例来具体表现出这几种常见值的注入：
普通值注入、bean注入、数组注入、List注入、Map注入、Set注入、NULL注入、Properties注入
1、新建module，普通maven项目，项目结构如图所示：
2、实体类内容
（1）Address类：
package com.wang.pojo;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}
（2）Student类：
package com.wang.pojo;
import java.util.*;
public class Student {
private String name;
private Address address;
private String[]books;
private List<String>hobbies;
private Map<String,String>card;
private Set<String>games;
private String wife;
private Properties info;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List<String> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
public Map<String, String> getCard() {
return card;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public Set<String> getGames() {
return games;
}
public void setGames(Set<String> games) {
this.games = games;
}
public String getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address=" + address +
", books=" + Arrays.toString(books) +
", hobbies=" + hobbies +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
其中，Address的作用就是为了在学生实体类中，在beans内实现bean注入（回忆一下mybatis的bean注入方式，ref，想起来了吗？）
3、配置文件beans.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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="address" class="com.wang.pojo.Address">
<property name="address" value="法外狂徒所在之地"/>
</bean>
<bean id="student" class="com.wang.pojo.Student">
<!--普通值注入，value-->
<property name="name" value="张三"/>
<!--bean注入，ref-->
<property name="address" ref="address"/>
<!--数组-->
<property name="books">
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>三国演义</value>
</array>
</property>
<!--List-->
<property name="hobbies">
<list>
<value>打篮球</value>
<value>学习</value>
<value>爱老婆</value>
</list>
</property>
<!--Map-->
<property name="card">
<map>
<entry key="学生证" value="202001080108"></entry>
<entry key="身份证" value="350305200109111439"></entry>
</map>
</property>
<!--Set-->
<property name="games">
<set>
<value>穿越火线</value>
<value>王者荣耀</value>
</set>
</property>
<!--NULL-->
<property name="wife">
<null></null>
</property>
<!--Properties-->
<property name="info">
<props>
<prop key="出生地">福建莆田</prop>
<prop key="现居住地">湖南长沙</prop>
</props>
</property>
</bean>
</beans>
拓展方式注入-c命名和p命名空间注入
p命名空间针对的是属性property的值，而c命名空间则针对的是constructor-arg注入即构造器注入，记得分别要在beans中引入：
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
假设我构造了一个User类，只有姓名和年龄两个输入，则：
（1）使用p构造：
<bean id="user" class="com.wang.pojo.User" p:name="王雄俊" p:age="20"/>
（2）使用c构造：
<bean id="user2" class="com.wang.pojo.User" c:age="18" c:name="王帅俊"/>
Bean的作用域
1、单例模式：Spring默认机制
<bean id="user" class="com.wang.pojo.User" c:age="18" c:name="王雄俊" scope="singleton">
2、原型模式：每次从容器中get的时候，都会产生一个新的对象
<bean id="user" class="com.wang.pojo.User" scope="prototype"/>
找个时间把单例模式和多例模式的问题抠清楚
Bean的自动装配
自动装配是Spring满足bean依赖的一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性
三种装配方式
1、在xml中显式的配置
2、在java中显式的配置
3、隐式的自动装配bean（重点）
测试
（1）Cat类：
package com.wang.pojo;
public class Cat {
public void shout(){
System.out.println("miao~");
}
}
（2）Dog类：
package com.wang.pojo;
public class Dog {
public void shout(){
System.out.println("wang~");
}
}
（3）People类：
package com.wang.pojo;
public class People {
private Cat cat;
private Dog dog;
private String name;
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "People{" +
"cat=" + cat +
", dog=" + dog +
", name='" + name + '\'' +
'}';
}
}
（4）beans.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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="cat" class="com.wang.pojo.Cat"/>
<bean id="dog" class="com.wang.pojo.Dog"/>
<bean id="people" class="com.wang.pojo.People">
<property name="name" value="王雄俊"/>
<property name="cat" ref="cat"></property>
<property name="dog" ref="dog"></property>
</bean>
</beans>
（5）MyTest类：
import com.wang.pojo.People;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test1(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people", People.class);
people.getDog().shout();
people.getCat().shout();
}
}
运行结果：
wang~
miao~
如上是正常的一个xml装配。
思考一个问题，如果我们有很多个属性（如人可以有非常多的宠物）需要装配，如果还是一个个的property敲进去不会很费时间吗？
引入byName自动装配
把对people的装配改为：
<bean id="people" class="com.wang.pojo.People" autowrite="byName">
<property name="name" value="王雄俊"/>
</bean>
byName：会自动在容器上下文查找，和自己对象set方法后面的值对应的bean id。
<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="cat" class="com.wang.pojo.Cat"/>
<bean id="dog222" class="com.wang.pojo.Dog"/>
<bean id="people" class="com.wang.pojo.People" autowire="byName">
<property name="name" value="王雄俊"/>
</bean>
</beans>
这个代码就会报错，因为byName对应的名字本就应该为对象中set方法背后的Dog的首字母小写即dog
byType自动装配
<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="cat" class="com.wang.pojo.Cat"/>
<bean id="dog2222" class="com.wang.pojo.Dog"/>
<bean id="people" class="com.wang.pojo.People" autowire="byType">
<property name="name" value="王雄俊"/>
</bean>
</beans>
根据类型（找class）来找，这样不会报错，甚至把前面的dog或者cat的id都去掉都能成功！
使用注解开发
配置文件applicationContext中的内容：
<?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
https://www.springframework.org/schema/context/spring-context.xsd">
<!--把pojo包目录下的类全部托管，利用Component组件来进行托管-->
<context:component-scan base-package="com.wang.pojo"/>
<context:annotation-config/>
</beans>
有关于注解的说明：
## 注解说明
- @Autowired：自动装配，通过类型、名字
如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value="xxx")
- @Nullable：字段标记了这个注解，说明这个字段可以为NULL
- @Resource：自动装配，通过名字、类型
- @Component：组件，放在类上，说明这个类被Spring管理了，就是bean！
- @Value：如Value("王雄俊")相当于在xml文件中的<property name="name" value="王雄俊">
这个注解也可以放在setName方法上，也可以把注解的内容打入
- 衍生的注解：
@Component有几个衍生注解，我们在web开发中，会按照MVC三层架构分层！
dao【@Repository】
service【@Service】
controller【@Controller】
功能是一样的，只是为了区分不同的层
- 作用域：@Scope("prototype")
- 小结：
xml更加万能，适用于任何场合，维护简单方便
注解，不是自己的类就使用不了，也就是用完注解，别的类要引用这个类无法实现引用。维护相对复杂
xml和bean的最佳实践：xml用来管理bean，注解只完成属性的注入（如Array、List中注入属性，用xml较为复杂）
使用java的方式配置Spring（必会！为springboot打好预防针）
现在要完全不使用Spring的配置了，全权交给java来做！
JavaConfig是Spring的一个子项目，在Spring4之后，已经成为了一个核心功能。
1、新建module，项目结构如下：
有没有注意到什么不同？resources并没有任何内容，这里并不打算利用xml来配置，来实现把那些实现装到容器中。
（1）User类：
package com.wang.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//这里这个注解的意思，就说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("王雄俊")//属性注入
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
（2）WangConfig类：
package com.wang.config;
import com.wang.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration//这个也会被Spring容器托管，注册到容器汇总，因为它本身就是一个Component
//@Configuration代表这是一个配置类，和我们之前看的beans.xml是一个意思
@ComponentScan("com.wang.pojo")//这个方式是直接扫描包，也要掌握
@Import(WangConfig2.class)//这个和之前的import意思差不多，只不过引入的对象不再是对应的绝对路径，而是类名
public class WangConfig {
@Bean//注册一个bean，就相当于之前写的一个bean标签
//这个方法的名字，就相当于bean标签中的id属性
//这个方法的返回值，就相当于bean标签中的class属性
public User getUser(){
return new User();//就是返回要注入到bean中的对象
}
}
（3）WangConfig2类（也就是为了价格配置，好让WangConfig类用import引用）：
package com.wang.config;
import org.springframework.context.annotation.Configuration;
@Configuration
public class WangConfig2 {
}
（4）MyTest类：
import com.wang.config.WangConfig;
import com.wang.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyTest {
public static void main(String[] args) {
//若完全使用了配置类去操作，就只能使用AnnotationConfig上下文来获取容器，通过配置类的class
ApplicationContext context = new AnnotationConfigApplicationContext(WangConfig.class);
//注意：我们要用getUser，表示的是WangConfig的bean方法
User getUser = context.getBean("getUser", User.class);
System.out.println(getUser.getName());
}
}
代理模式
为什么要学习代理模式？因为这就是面向SpringAOP的底层【SpringAOP和SpringAMV】
代理模式的分类：
1、静态代理
2、动态代理
给出一个代理模式的实际应用图，辅助理解，该图用的是“遇见狂神说”的图，很好理解，理解其思维方式，才方便写代码。
1、静态代理
角色分析：
（1）抽象角色：一般会使用接口或者抽象类来解决
（2）真实角色：被代理的角色
（3）代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
（4）客户：访问代理对象的人
来写个程序演示一下：
文件结构比较简单 来看看各个文件的代码：
（1）Rent接口：
package com.wang.demo01;
public interface Rent {
public void rent();
}
（2）Host类：
package com.wang.demo01;
//房东
public class Host implements Rent{
@Override
public void rent() {
System.out.println("房东要出租房子！");
}
}
（3）Proxy类：
package com.wang.demo01;
//代理
public class Proxy implements Rent{
private Host host;
public Proxy(){
}
public Proxy(Host host){
this.host=host;
}
@Override
public void rent() {
seeHouse();
host.rent();
hetong();
fare();
}
//看房
public void seeHouse(){
System.out.println("中介带你看房");
}
//签合同名
public void hetong(){
System.out.println("签合同");
}
//收中介费
public void fare(){
System.out.println("收中介费");
}
}
（4）Clint类：
package com.wang.demo01;
public class Client {
public static void main(String[] args) {
//房东要租出房子
Host host=new Host();
//代理，中介帮房东租房子
//但是中介一般会做一些附属操作
Proxy proxy = new Proxy(host);
//你不用面对房东，直接找中介租房
proxy.rent();
}
}
如上代码的注释说明的很清楚，中介作为中间的接口，除了实现租房这个一定要有的要求，还做了别的一些附属操作。
代理模式的好处：
（1）可以使真实角色的操作更加纯粹，不应去关注一些公共的业务。
（2）公共也就交给代理角色，实现了业务的分工！
（3）公共业务发生扩展的时候，方便集中管理！
缺点：一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低。
再讲一个例子来理解静态代理
假设有一个公司的业务层，也就是相当于一个底层的代码，里面实现的功能为增删改查，用户可以实现这个增删改查。
如果用户每次实现增删改查的任意一个操作都会打印日志操作来显示究竟是打印了什么。
一般的思维可能会想着改变业务逻辑代码，在每个方法的实现上加上日志的打印。
但是这样可能会出现一个问题，这可是整个公司的业务层，要是被我们改崩了怎么办？这个问题会很严重。
因此引入代理，也就是上一个例子的中介，在这里封装一个log方法来实现，避免了修改公司的业务层代码。
总结：在不改变原有业务层代码的情况下，新增功能！
动态代理详解
静态代理的代码量太大了！
1、动态代理和静态代理角色一样
2、动态代理的代理类是动态生成的，不是我们直接写好的
3、动态代理分为两大类：基于接口的动态代理，基于类的动态代理
（1）基于接口：JDK动态代理（原生）
（2）基于类：cglib
（3）java字节码实现：javasist
需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序
InvocationHandler
InvocationHandler是在反射包下的，是由代理实例的调用处理程序实现的接口。
每个代理实例都有一个关联的调用处理程序，当在处理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。
方法：invoke。
具体的内容就在官方文档，这里就不再阐释，但是将会在代码样例中具体演示。建议先去看官方文档中对该方法的描述，再看一下下面的样例来加深印象和理解。
Proxy
也是来源于反射包下的类，Proxy提供了创建代理类和实现类的方法，它也是由这些方法创建的所有动态代理类的超类。
使用方法也省略，先去看文档，具体实现就看代码。
步骤：
1、首先，新建一个包，把前面样例的Host类和Rent接口都拷贝过来。
2、新建一个代理调用处理程序，这是一个接口，也就是前面所说的InvocationHandler，起名为ProxyInvocationHandler，我们会用这个类，自动生成代理类。
接下来是重点，也即是ProxyInvacationHandler类的内容：
package com.wang.demo2;
import com.sun.org.apache.bcel.internal.generic.DREM;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//利用这个类，自动生成代理类
//不同于之前的代理类，之前的代理类写死了一个Proxy
//现在将要动态生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成得到代理类
/*
参数1：指明要加载到类的哪个位置
参数2：表示要代理的接口
参数3；要调用给哪个InvocationHandler处理
* */
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
}
//处理代理实例，并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//动态代理的本质就是使用反射机制实现
seeHouse();
Object result = method.invoke(rent, args);
fare();
return result;
}
public void seeHouse(){
System.out.println("中介带看房子");
}
public void fare(){
System.out.println("收中介费");
}
}
Client类内容，注意比较区别：
package com.wang.demo2;
import com.wang.demo2.Host;
import com.wang.demo2.ProxyInvocationHandler;
public class Client {
public static void main(String[] args) {
//真实角色
Host host=new Host();
//代理角色，现在没有，要通过处理程序ProxyInvocationHandler生成一个代理类
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//通过调用程序处理角色来处理我们要调用的接口对象
pih.setRent(host);
Rent proxy= (Rent) pih.getProxy();//这里的proxy就是动态生成的，并没有去写中介这么一个代理类
proxy.rent();
}
}
运行则可以生成预期的结果
接下里直接给出动态生成代理类的通用模板：
package com.wang.demo3;
import com.wang.demo2.Rent;
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(Rent rent) {
this.target = target;
}
//生成得到代理类
/*
参数1：指明要加载到类的哪个位置
参数2：表示要代理的接口
参数3；要调用给哪个InvocationHandler处理
* */
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
//处理代理实例，并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//动态代理的本质就是使用反射机制实现
Object result = method.invoke(target, args);
return result;
}
}
动态代理除了之前所说的代理模式的好处知识外，还包括：
（1）一个动态代理类代理的是一个接口，一般就是对应的一类业务，修改的成本低
（2）一个动态代理类可以代理多个类，只要是实现了同一个接口即可！
AOP
1、什么是AOP
AOP：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（其实就把前面的例子的房东要出租房子了这个事情看成一个切面，那么在这之前要看房子，在这之后要收中介费，这就是一种面向切面的编程）
2、利用Spring实现AOP
使用AOP植入，需要导入一个依赖包。
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
3、具体实现
新建项目，目录如下：
其中：
（1）UserService接口：
package com.wang.service;
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
（2）UserServiceImpl类：
package com.wang.service;
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("增加了一个用户");
}
@Override
public void delete() {
System.out.println("删除了一个用户");
}
@Override
public void update() {
System.out.println("更新了一个用户");
}
@Override
public void query() {
System.out.println("查询了一个用户");
}
}
（3）Log类：
package com.wang.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {
//method：要执行的目标对象的方法
//args：参数
//target：目标对象
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
}
}
（4）AfterLog类：
package com.wang.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
//returnValue：返回值
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("执行了"+method.getName()+"返回结果为："+returnValue);
}
}
（5）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"
xmlns:aop="http://www.springframework.org/schema/aop"
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">
<!--注册bean-->
<bean id="userService" class="com.wang.service.UserServiceImpl"/>
<bean id="log" class="com.wang.log.Log"/>
<bean id="afterLog" class="com.wang.log.AfterLog"/>
<!--配置aop：需要aop的约束-->
<aop:config>
<!--切入点 expression：表达式 execution(要执行的位置) *代表切入所有方法-->
<aop:pointcut id="pointcut" expression="execution(* com.wang.service.UserServiceImpl.*(..))"/>
<!--执行环绕增加-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
（6）MyTest类：
import com.wang.service.UserService;
import com.wang.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
/*下面这个代码就错了，因为动态代理代理的是接口而不是类
UserServiceImpl userService = context.getBean("userService", UserServiceImpl.class);
*/
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
运行结果：
com.wang.service.UserServiceImpl的add被执行了
增加了一个用户
执行了add返回结果为：null
Process finished with exit code 0