还是那个意思，速成只是为了迅速做个项目提高动手能力，最后还是要回归把所有框架的精髓原理弄清楚！
只是参考，每个人都会遇到不同的问题，根本的东西是万万离不开官方文档的，这里分享一下Spring5的中文官方文档：
Spring官方文档

第一个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;}@Overridepublic 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/beanshttp://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{@Overridepublic void getUser() {System.out.println("默认获取用户的数据");}
}

（3）UserDaoMysqlImpl实现类：

package com.wang.dao;public class UserDaoMysqlImpl implements UserDao{@Overridepublic void getUser() {System.out.println("Mysql获取用户数据！");}
}

（4）UserDaoOracleImpl实现类：

package com.wang.dao;public class UserDaoOracleImpl implements UserDao{@Overridepublic 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();@Overridepublic 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) {//获取ApplicationContextApplicationContext 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/beanshttp://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/beanshttp://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"来取得这个容器对应的类--><!--    &lt;!&ndash;第一种方式：下标赋值&ndash;&gt;-->
<!--    <bean id="user" class="com.wang.pojo.User">-->
<!--        <constructor-arg index="0" value="俊哥"/>-->
<!--    </bean>--><!--    &lt;!&ndash;第二种方式，通过类型创建，不建议使用。比如有两个参数类型都是一样的呢？&ndash;&gt;-->
<!--    <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;}@Overridepublic 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;}@Overridepublic 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/beanshttp://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;}@Overridepublic 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/beanshttp://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 {@Testpublic 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/beanshttp://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/beanshttp://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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://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;}@Overridepublic 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上下文来获取容器，通过配置类的classApplicationContext 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{@Overridepublic 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;}@Overridepublic 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);}//处理代理实例，并返回结果@Overridepublic 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);}//处理代理实例，并返回结果@Overridepublic 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{@Overridepublic void add() {System.out.println("增加了一个用户");}@Overridepublic void delete() {System.out.println("删除了一个用户");}@Overridepublic void update() {System.out.println("更新了一个用户");}@Overridepublic 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：目标对象@Overridepublic 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：返回值@Overridepublic 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.xsdhttp://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

SSM框架速成2——Spring5速成总结相关推荐

最新版的SSM框架spring5.0搭建教程(附源码)
<p>用SSM框架已经有一段时间了,但都没有完整地搭建过一次工程.前段时间比较有时间就自己试着搭建了一下,差不多都是用的最新的spring版本了,然后就在这个基础上做了很多的实验测试.最近 ...
ssm框架requestmapping找不到_从MVC原理开始手敲一个MVC框架，带你体会当大神的乐趣...
每一个程序员,在刚入行时学的第一个框架应该就是ssm了,其他的各种学习框架都是后期在工作中,随着业务的不断复杂,在工作和bug中不断成长起来的,但是最经典的应该还是最一开始的时候ssm框架吧当时刚学 ...
Java学习路线，Java SE，EE，ME的区别，SSM框架基本概念
1.尚硅谷视频课程:https://www.bilibili.com/read/cv5216534 初学者可按照尚硅谷公开的JAVA视频最快学习路线: JavaSE --> MySQL–> ...
使用maven搭建ssm框架的javaweb项目
目前主流的javaweb项目,常会用到ssm(Spring+Spring MVC+Mybatis)框架来搭建项目的主体框架,本篇介绍搭建SSM框架的maven项目的实施流程.记之共享! 一.SSM框架 ...
SSM框架——Spring+SpringMVC+Mybatis的搭建教程
一:概述 SSM框架在项目开发中经常使用到,相比于SSH框架,它在仅几年的开发中运用的更加广泛. Spring作为一个轻量级的框架,有很多的拓展功能,最主要的我们一般项目使用的就是IOC和AOP. S ...
初学ssm框架的信息
ssm框架,就是Spring ,SpringMVC ,mybstis 的简称,我们是从mybstis 开始学起的,mybatis的作用作为一个连接数据库的框架,可以很好配置连接好数据库, 有mybat ...
ssm框架mysql配置_ssm框架使用详解配置两个数据源
学习ssm框架已经快一年了,今天把这个框架总结一下. SSM 就是指 spring.SpringMVC和Mybatis.先说一下基本概念(百度上搜的) 1.基本概念 1.1.Spring Spring ...
SSM框架之批量增加示例(同步请求jsp视图解析)
准备环境:SSM框架+JDK8/JDK7+MySQL5.7+MAVEN3以上+Tomcat8/7应用服务器示例说明: 分发给用户优惠券,通过checkbox选中批量分发,对应也就是批量增加. 对于公 ...
ssm框架实现学生成绩管理系统
学习ssm框架,写的一个小项目,参考实现的功能有:学生信息增删改查,成绩信息查询,修改,求平均值, 附上链接,欢迎下载 git clone https://gitee.com/LOL_toulan/ ...

SSM框架速成2——Spring5速成总结

目录