本文详细介绍了Spring框架的核心概念，包括IOC（控制反转）、AOP（面向切面编程）以及如何与Mybatis进行整合。首先，讲解了Spring的IOC容器如何通过XML或注解实现对象的创建和依赖注入，然后深入探讨了AOP的原理和在Spring中的实现，最后演示了如何在Spring中配置和管理Mybatis，实现声明式事务处理。
Spring
1.Spring
1.1、简介
-
spring：春天-------->给软件行业带来了春天！
-
2002，首次推出了Spring框架的雏形：interface21框架！
-
Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。
-
Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
-
spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
-
SSH：Struct2+Spring+Hibernate！
-
SSM：SpringMvc+Spring+Mybatis！
官网：https://spring.io/projects/spring-framework#overview
官方下载地址：https://repo.spring.io/release/org/springframework/spring/
GitHub：https://github.com/spring-projects/spring-framework
中文文档：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.9.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.9.RELEASE</version>
</dependency>
1.2、优点
- spring是一个开源的免费的框架（容器）！
- Spring是一个轻量级的，非入侵式的框架！
- 控制反转（IOC），面向切面编程（AOP）！
- 支持事务的处理，对框架整合的支持！
总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！
1.3、组成
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m9hOnHKY-1623488913857)(Spring.assets/1-3组成.PNG)]
1.4、扩展
在Spring的官网有这个介绍：现代化的Java开发！说白就是基于Spring的开发
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iXvVURJb-1623488913859)(Spring.assets/1-4扩展.PNG)]
- Spring Boot
- 一个快速开发的脚手架。
- 基于SpringBoot可以快速的开发单个微服务。
- 约定大于配置！
- Spring Cloud
- SpringCloud是基于SpringBoot实现的。
因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用！
弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称“配置地狱！”
2、IOC理论推导(项目1)
-
UserDao 接口
public interface UserDao { void getUser(); } -
UserDaoImpl 实现类
public class UserDaoImpl implements UserDao{ public void getUser(){ System.out.println("默认获取用户的数据"); } }另三个同样实例:
public class UserDaoMysqlImpl implements UserDao { public void getUser() { System.out.println("Mysql获取用户数据！"); } }public class UserDaoOracleImpl implements UserDao{ public void getUser() { System.out.println("Oracle获取用户数据！"); } }public class UserDaoSqlserverImpl implements UserDao{ public void getUser() { System.out.println("Sqlserver获取用户数据！"); } } -
UserService 业务接口
public interface UserService { void getUser(); } -
UserServiceImpl 业务实现类
public class UserServiceImpl implements UserService{
private UserDao userDao;
//利用set进行动态实现值的注入！
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void getUser() {
userDao.getUser();
}
}
测试：
public class MyTest { public static void main(String[] args) { //用户实际调用的是业务层，dao层他们不需要接触！ UserServiceImpl userService = new UserServiceImpl(); userService.setUserDao(new UserDaoImpl()); userService.getUser(); }}
在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改元代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FKOkGegc-1623488913861)(Spring.assets/2IOC理论推导.PNG)]
我们使用一个Set接口实现。已经发生了革命性的变化！
private UserDao userDao;//利用set进行动态实现值的注入！public void setUserDao(UserDao userDao) { this.userDao = userDao;}
- 之前，程序是主动创建！控制权在程序员手上！
- 使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象！
这种思想，从本质上解决了问题，我们程序员不再用去管理对象的创建了。系统的耦合性大大降低~，可以更加专注的在业务的实现上！这是IOC的原型！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RgUobBBw-1623488913863)(Spring.assets/2IOC理论推导-2.PNG)]
IOC本质
控制反转IoC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现注入IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和现实分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）
3、HelloSpring(项目2)
-
实现类
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 + '\'' + '}'; }} -
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 https://www.springframework.org/schema/beans/spring-beans.xsd"> <!--使用Spring来创建对象，在Spring这些都成为Bean 类型 变量名 = new 类型(); Hello hello = new Hello(); id=变量名 class=new 的对象 property 相当于给对象中的属性设置一个值！ --> <bean id="hello" class="com.kuang.pojo.Hello"> <property name="str" value="Spring"/> </bean></beans>项目一配置：
<?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"> <!--使用Spring来创建对象，在Spring这些都成为Bean 类型 变量名 = new 类型(); Hello hello = new Hello(); id=变量名 class=new 的对象 property 相当于给对象中的属性设置一个值！ --> <bean id="mysqlImpl" class="com.kuang.dao.UserDaoMysqlImpl"/> <bean id="oracleImpl" class="com.kuang.dao.UserDaoOracleImpl"/> <bean id="SqlServerImpl" class="com.kuang.dao.UserDaoSqlserverImpl"/> <bean id="UserServiceImpl" class="com.kuang.service.UserServiceImpl"> <property name="userDao" ref="SqlServerImpl"></property> </bean> <!-- ref：引用Spring容器中创建好的对象 value：具体的值，基本数据类型！ --></beans> -
测试：
import com.kuang.pojo.Hello;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中的管理了，我们要使用，直接里面取出来就可以了！ Hello hello = (Hello) context.getBean("hello"); System.out.println( hello.toString()); }}项目一测试：
public class MyTest { public static void main(String[] args) { //获取ApplicationContext:拿到Spring的容器 ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); //容器在手，天下我要，需要什么，就直接get什么! UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl"); userServiceImpl.getUser(); }}思考问题？
-
Hello对象是谁创建的?
Hello对象是有Spring创建的。
-
Hello对象的属性是怎么设置的？
Hello对象的属性是由Spring容器设置的。
这个过程就叫控制反转：
控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。
反转：程序本身不创建对象，而变成被动的接收对象。
依赖注入：就是利用set方法来进行注入的。
IOC是一种编程思想，由主动的编程变成被动的接收。
可以通过new ClassPathXmlApplicationContext去浏览一下底层源码。
OK，到了现在，我们彻底不用再程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IoC，一句话搞定：对象由Spring来创建，管理，装配!
-
4、IOC创建对象的方式（项目3）
user类
public class User { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public void show(){ System.out.println("name="+name); }}
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 https://www.springframework.org/schema/beans/spring-beans.xsd"></beans>
-
使用无参构造创建对象，默认！
user类添加
public User(){ System.out.println("User的无参构造！");}beans.xml配置添加
<bean id="user" class="com.kuang.pojo.User"> <property name="name" value="秦疆"/></bean> -
假设我们要使用有参构造创建对象。
user类添加
public User(String name){ this.name=name;}-
下标赋值
beans.xml配置添加
<!--第一种，下标赋值！--><bean id="user" class="com.kuang.pojo.User"> <constructor-arg index="0" value="狂神说Java"/></bean> -
类型
beans.xml配置添加
<!--第二种方式：通过类型创建，不建议使用！--><bean id="user" class="com.kuang.pojo.User"> <constructor-arg type="java.lang.String" value="qinjiang"/></bean> -
参数名
<!--第三种，直接通过参数名来设置--><bean id="user" class="com.kuang.pojo.User"> <constructor-arg name="name" value="秦疆"/></bean>
-
测试：
public class MyTest { public static void main(String[] args) { //Spring容器 ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); User user=(User) context.getBean("user"); user.show(); }}
总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！
5、Spring配置
5.1、别名
<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象--> <alias name="user" alias="userNew"/>
测试：
//别名User user=(User) context.getBean("userNew");
5.2、Bean的配置
<!-- id：bean的唯一标识符，也就是相当于我们学的对象名 class：bean对象所对应的全限定名： 包名+类型 name：也就是别名，而且name可以同时取多个别名 --><bean id="userT" class="com.kuang.pojo.UserT" name="user2 u2,u3;u4"> <property name="name" value="西部开源"/></bean>
测试：
UserT userT=(UserT) context.getBean("user2");//user2 u2 u3 u4都可以
5.3、import
这个import，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个
假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！
-
张三
-
李四
-
王五
-
applicationContext.xml
<import resource="beans.xml"/><import resource="beans2.xml"/><import resource="beans3.xml"/>
使用的时候，直接使用总的配置就可以了
6、依赖注入（项目4）
6.1、构造器注入
前面已经说了
6.2、Set方式注入【重点】
- 依赖注入：Set注入！
- 依赖：bean对象的创建依赖于容器！
- 注入：bean对象中的所有属性，有容器来注入！
【环境搭建】
-
复杂类型
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 + '\'' + '}'; }} -
真实测试对象(get，set，tostring自己打)
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;} -
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 https://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="student" class="com.kuang.pojo.Student"> <!--第一种，普通值注入，value--> <property name="name" value="秦疆"/> </bean></beans> -
测试类
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.getName()); }}
完善注入信息
<?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="西安"/> </bean> <bean id="student" class="com.kuang.pojo.Student"> <!--第一种，普通值注入，value--> <property name="name" value="秦疆"/> <!--第二种：Bean注入，ref--> <property name="address" ref="address"/> <!--数组注入--> <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="1111111111111111111111"></entry> <entry key="银行卡" value="222222222222222222222222"></entry> </map> </property> <!--Set注入--> <property name="games"> <set> <value>LOL</value> <value>COC</value> <value>BOB</value> </set> </property> <!--null注入--> <property name="wife"> <null/> </property> <!--Properties注入--> <property name="info"> <props> <prop key="driver">20201223</prop> <prop key="url">男</prop> <prop key="username">root</prop> <prop key="password">123456</prop> </props> </property> </bean></beans>
6.3、拓展方式注入
我们可以使用p命名空间和c命名空间进行注入
官方解释：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iD9rTRiG-1623488913864)(Spring.assets/6-3拓展方式注入.PNG)]
使用！
<?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"/> <!--c命名空间注入，通过构造器注入：construct-args--> <bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="狂神"/></beans>
测试：
@Testpublic void test2(){ ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml"); User user = (User) context.getBean("user"); System.out.println(user.toString());}@Testpublic void test3(){ ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml"); User user = (User) context.getBean("user2"); System.out.println(user.toString());}
注意点：p命名和c命名空间不能直接使用，需要导入xml约束
xmlns:p="http://www.springframework.org/schema/p"xmlns:c="http://www.springframework.org/schema/c"
6.4、bean的作用域
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SarSiWZq-1623488913865)(Spring.assets/6-4bean的作用域.PNG)]
-
单例模式（Spring默认机制）
<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="狂神" scope="singleton"/> -
原型模式：每次从容器中get的时候，都会产生一个新对象！
<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="狂神" scope="prototype"/> -
其余的request、session、application、这些个只能在web开发中使用到！
7、Bean的自动装配（项目5）
- 自动装配Spring满足bean依赖的一种方式！
- Spring会在上下文中自动寻找，并自动给bean装配属性！
在Spring中有三种装配的方式
- 在xml中显示的配置
- 在java中显示配置
- 隐式的自动装配bean【重要】
7.1、测试
- 环境搭建：一个人有两个宠物！
public class Dog { public void shout(){ System.out.println("wang~"); }}
public class Cat { public void shout(){ System.out.println("miao~"); }}
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 + '\'' + '}'; }}
7.2、byName自动装配
<bean id="cat" class="com.kuang.pojo.Cat"/><bean id="dog" class="com.kuang.pojo.Dog"/><!-- byName：会自动在容器上下文中查找，和自己对象set方法后面的值相对应的bean id！ --><bean id="people" class="com.kuang.pojo.People" autowire="byName"> <property name="name" value="小狂神呀"/></bean>
7.3、byType自动装配
<bean class="com.kuang.pojo.Cat"/><bean class="com.kuang.pojo.Dog"/><!-- byName：会自动在容器上下文中查找，和自己对象set方法后面的值相对应的bean id！ byType: 会自动在容器上下文中查找，和自己对象属性类型相同的bean！ --><bean id="people" class="com.kuang.pojo.People" autowire="byType"> <property name="name" value="小狂神呀"/></bean>
小结：
- byName的时候，需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
- byType的时候，需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！
7.4、使用注解实现自动装配
jdk1.5支持的注解，Spring2.5就支持注解了！
The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.
要使用注解须知：
-
导入约束：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" 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"> <context:annotation-config/></beans>@Autowired
直接在属性上使用即可！也可以在set方式上使用！
使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC（spring）容器中存在，且符合名字byName！
科普：
```java
@Nullable 字段标记了这个注解，说明这个字段可以为null;
public void setName(@Nullable String name) {
this.name = name;
}
``````
public @interface Autowired { boolean required() default true;}
测试代码：
public class People { //如果显示定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空 @Autowired(required = false) private Cat cat; @Autowired private Dog dog; private String name;}
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入！
public class People { @Autowired(required = false) @Qualifier(value = "cat11") private Cat cat; @Autowired @Qualifier(value = "dog222") private Dog dog; private String name;}
@Resource注解
public class People { @Resource private Cat cat; @Resource(name = "dog2") private Dog dog;}
小结：
@Resource和@Autowired的区别：
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】
- @Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
- 执行顺序不同：@Autowired通过byType的方式实现，@Resource默认通过byName的方式实现。
8、使用注解开发(项目6)
在Spring4之后，需使用注解开发，必须要保证aop的包导入了
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uzPdC3HL-1623488913865)(Spring.assets/8使用注解开发.PNG)]
使用注解需要导入context约束，增加注解的支持！
<?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 https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <!--指定要扫描的包，这个包下的注解就会失效--> <context:component-scan base-package="com.kuang"/> <context:annotation-config/></beans>
-
bean
-
属性如何注入
//等价于<bean id="user" class="com.kuang.pojo.User"/>//@Component 组件@Componentpublic class User { public String name ; //相当于<property name="name" value="狂神"/> @Value("狂神") public void setName(String name) { this.name = name; }} -
衍生的注解
@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
-
dao 【@Repository】
-
service【@Service】
-
cotroller【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
-
-
自动装配置
-@Autowired ：自动装配通过类型，名字 如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "xxx")-@Nullable 字段标记了这个注解，说明这个字段可以为null;-@Resource ：自动装配通过名字，类型 -
作用域
@Component@Scope("prototype")public class User { public String name ; //相当于<property name="name" value="狂神"/> @Value("狂神") public void setName(String name) { this.name = name; }} -
小结
xml与注解：
- xml更加万能，适合于任何场合！维护简单方便
- 注解 不是自己类使用不了，维护相对复杂！
xml与注解最佳实践
-
xml用来管理bean；
-
注解只负责完成属性的注入;
-
我们在使用的过程中，只需要助于一个问题：必须让注解生效，就需要开启注解的支持
<!--指定要扫描的包，这个包下的注解就会失效--> <context:component-scan base-package="com.kuang"/> <context:annotation-config/>
9、使用Java的方式配置Spring（项目7）
我们现在要完全不使用Spring的xml配置了，全权交给Java来做！
JavaConfig是Spring的一个子项目，在Spring 4之后，它成为了一个核心功能！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gqA8OYik-1623488913866)(Spring.assets/9使用Java的方式配置Spring.PNG)]
实体类：
//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中@Componentpublic 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 + '\'' + '}'; }}
配置文件：
//这个也会Spring容器托管，注册到了容器中，因为他本来就是一个@Component// @Configuration代表这是一个配置类，就和我们之前看的beans.xml@Configuration@ComponentScan("com.kuang.pojo")@Import(KuangConfig2.class)public class KuangConfig { //注册一个bean，就相当于我们之前写的一个bean标签 //这个方法的名字，就相当于bean标签中的id属性 //这个方法的返回值，就相当于bean标签中的class属性 @Bean public User getUser(){ return new User();//就是返回要注入到bean的对象！ } }
测试类：
public class MyTest { public static void main(String[] args) { //如果完全使用了配置类方式去做，我们就只能通过AnnotationConfig 上下文来获取容器，通过配置类的class对象加载！ ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class); User getUser = (User) context.getBean("getUser"); System.out.println(getUser.getName()); }}
这种纯Java的配置方式，早SpringBoot中随处可见！
10、代理模式（项目8）
为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】
代理模式的分类：
- 静态代理
- 动态代理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UjcuX4lg-1623488913866)(Spring.assets/10代理模式.PNG)]
10.1、静态代理（demo01）
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人！
代码步骤：
-
接口
//租房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 hetong(){ System.out.println("签租凭合同"); } //收中介费 public void fare(){ System.out.println("收中介费"); }} -
客户端访问代理角色
public class Client { public static void main(String[] args) { //房东要租房子 Host host=new Host(); //代理，中介帮房东租房子，但是呢？代理角色一般会有一些附属操作！ Proxy proxy=new Proxy(host); //你不用面对房东，直接找中介租房即可！ proxy.rent(); }}
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共也就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
缺点：
- 一个真实角色就会产生一个代理角;代码量会翻倍开发效率会变低
10.2、加深理解（demo02）
代码步骤：
-
接口
public interface UserService { public void add(); public void delete(); public void update(); public void query();} -
真实对象
//真实对象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 query() { System.out.println("查询了一个用户"); } //1.改变原有的业务代码，在公司是大忌！} -
代理角色
public class UserServiceProxy implements UserService{ private UserServiceImpl userService; public void setUserService(UserServiceImpl userService) { this.userService = userService; } public void add() { log("add"); userService.add(); } public void delete() { log("delete"); userService.delete(); } public void update() { log("update"); userService.update(); } public void query() { log("query"); userService.query(); } //日志方法 public void log(String msg){ System.out.println("[Debug]使用了"+msg+"方法"); }} -
客户端访问代理角色
public class Client { public static void main(String[] args) { UserServiceImpl userService=new UserServiceImpl(); UserServiceProxy proxy=new UserServiceProxy(); proxy.setUserService(userService); proxy.add(); }}
聊聊AOP
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kwYPA3Es-1623488913867)(Spring.assets/10-2加深理解.PNG)]
10.3、动态代理（demo03和demo04）
-
ProxyInvocationHandler通用(只需修改[替换]target即可)
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; } //生成得到代理类 protected 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); return result; }} -
测试
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.add(); }}
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写的！
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口—JDK 动态代理【我们在这里使用】
- 基于类：cglib
- java字节码实现：javasist
需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序
动态代理的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共也就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！
11、AOP（项目9）
11.1、什么是AOP
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VA1JZu5d-1623488913867)(Spring.assets/11-1什么是AOP.PNG)]
11.2、AOP在Spring中的作用
提供声明式业务；允许用户自定义切面
-
横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等……
-
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
-
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
-
目标（Target）：被通知对象。
-
代理（Proxy）：向目标对象应用通知之后创建的对象。
-
切入点（PointCut）：切面通知执行的“地点”的定义。
-
连接点（JointPoint）:与切入点匹配的执行点。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eRpMm4m8-1623488913868)(Spring.assets/11-2Aop在Spring中的作用.PNG)]
SpringAOP中，通过Advice定义横切逻辑，Spring中支持5中类型的Advice：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1hKQ6UuO-1623488913868)(Spring.assets/11-2Aop在Spring中的作用-2.PNG)]
即Aop在不改变原有代码的情况下，去增加新的功能。
11.3、使用Spring实现Aop
【重点】使用AOP织入，需要导入一个依赖包！
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --><dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.5</version></dependency>
方式一：使用Spring的API接口【主要SpringAPI接口实现】（service和Log包下所有）
-
log
public class Log implements MethodBeforeAdvice { //method: 要执行的目标对象的方法 //args：参数 //target：目标对象 public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了"); }}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); }} -
service
接口：
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("查询了一个用户"); }} -
applicationContext.xml配置：
<!--注册bean--><bean id="userService" class="com.kuang.service.UserServiceImpl"/><bean id="log" class="com.kuang.log.Log"/><bean id="afterLog" class="com.kuang.log.AfterLog"/><!--方式一：使用原生Spring API接口--><!--配置aop：需要导入aop的约束--><aop:config> <!--切入点：expression：表达式，execution(要执行的位置* * * * *)--> <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/> <!--执行环绕增加！--> <aop:advisor advice-ref="log" pointcut-ref="pointcut"/> <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/></aop:config> -
测试
public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //动态代理代理的是接口 UserService userService = (UserService) context.getBean("userService"); userService.add(); }}
方式二：自定义来实现AOP【主要是切面定义】（diy包下DiyPointCut）
1.DiyPointCut类
public class DiyPointCut { public void before(){ System.out.println("========方法执行前========"); } public void after(){ System.out.println("========方法执行后========"); }}
2.applicationContext.xml配置：
<!--方法二：自定义类--> <bean id="diy" class="com.kuang.diy.DiyPointCut"/> <aop:config> <!--自定义切面，ref要引用的类--> <aop:aspect ref="diy"> <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/> <!--通知--> <aop:before method="before" pointcut-ref="point"/> <aop:after method="after" pointcut-ref="point"/> </aop:aspect> </aop:config>
3.测试类
public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //动态代理代理的是接口 UserService userService = (UserService) context.getBean("userService"); userService.add(); }}
方式三：使用注解实现！（diy包下AnnotationPointCut）
-
AnnotationPointCut类
import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.Signature;import org.aspectj.lang.annotation.After;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;//方式三：使用注解方式实现AOP@Aspect//标注这个类是一个切面public class AnnotationPointCut { @Before("execution(* com.kuang.service.UserServiceImpl.*(..))") public void before(){ System.out.println("=====方法执行前====="); } @After("execution(* com.kuang.service.UserServiceImpl.*(..))") public void after(){ System.out.println("=====方法执行后====="); } //在环绕增强后中，我们可以给定一个参数，代表我们要获取处理切入的点： @Around("execution(* com.kuang.service.UserServiceImpl.*(..))") public void around(ProceedingJoinPoint jp) throws Throwable { System.out.println("环绕前"); //执行方法 Object proceed=jp.proceed(); System.out.println("环绕后");// Signature signature = jp.getSignature();//获得签名// System.out.println("signature:"+signature);// System.out.println(proceed); }} -
applicationContext.xml配置
<!--方式三--><bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/><!--开启注解支持！JDK（默认 proxy-target-class="false"） cglib（proxy-target-class="true"）--><aop:aspectj-autoproxy/> -
测试类
public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //动态代理代理的是接口 UserService userService = (UserService) context.getBean("userService"); userService.add(); }}
12、整合Mybatis（项目10）
步骤：
- 导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关的
- aop织入
- mybatis-spring【new】
- 编写配置文件
- 测试
12.1、回忆mybatis
-
编写实体类
@Datapublic class User { private int id; private String name; private String pwd;} -
编写核心配置文件
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"><!--configuration核心配置文件--><configuration> <typeAliases> <package name="com.kuang.pojo"/> </typeAliases> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> </environment> </environments> <!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！--> <mappers> <mapper class="com.kuang.mapper.UserMapper"/> </mappers></configuration> -
编写接口
public interface UserMapper { public List<User> selectUser();} -
编写Mapper.xml(经常报错是因为mapper后面没写namespace=“com.kuang.mapper.UserMapper”)
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><!--configuration核心配置文件--><mapper namespace="com.kuang.mapper.UserMapper"> <select id="selectUser" resultType="user"> select * from mybatis.user; </select></mapper> -
测试
import com.kuang.mapper.UserMapper;import com.kuang.pojo.User;import org.apache.ibatis.io.Resources;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;import org.junit.Test;import java.io.IOException;import java.io.InputStream;import java.util.List;public class MyTest { @Test public void test() throws IOException { String resources="mybatis-config.xml"; InputStream in = Resources.getResourceAsStream(resources); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in); SqlSession sqlSession = sqlSessionFactory.openSession(true); UserMapper mapper = sqlSession.getMapper(UserMapper.class); List<User> userList = mapper.selectUser(); for (User user : userList) { System.out.println(user); } }}
12.2、Mybatis-spring
1-3步都是写在spring-dao.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"></beans>
mybatis-config,xml配置：
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"><!--configuration核心配置文件--><configuration> <typeAliases> <package name="com.kuang.pojo"/> </typeAliases> <!--设置--> <!--<settings>--> <!--<setting name="" value=""/>--> <!--</settings>--></configuration>
实体类：
@Datapublic class User { private int id; private String name; private String pwd;}
方式一：
-
编写数据源配置
<!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid 我们这里使用Spring提供的JDBC：org.springframework.jdbc.datasource --><bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="root"/></bean> -
sqlSessionFactory
<!--sqlSessionFactory--><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="datasource" /> <!--绑定Mybatis配置文件--> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"/></bean> -
sqlSessionTemplate
<!--SqlSessionTemplate:就是我们使用的sqlSession--><bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/></bean> -
需要给接口加实现类【UserMapperImpl】
接口：
public interface UserMapper { public List<User> selectUser();}实现类：
public class UserMapperImpl implements UserMapper{ //我们的所有操作，都使用sqlSession来执行，在原来，现在都使用SqlSessionTemplate; private SqlSessionTemplate sqlSession; public void setSqlSession(SqlSessionTemplate sqlSession) { this.sqlSession = sqlSession; } public List<User> selectUser() { UserMapper mapper=sqlSession.getMapper(UserMapper.class); return mapper.selectUser(); }} -
将自己写的实现类，注入到Spring中，可以应用多个配置整合
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 https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <import resource="spring-dao.xml"/> <!----> <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl"> <property name="sqlSession" ref="sqlSession"/> </bean></beans> -
测试使用即可
public class MyTest { @Test public void test() throws IOException { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserMapper userMapper = context.getBean("userMapper", UserMapper.class); for (User user : userMapper.selectUser()) { System.out.println(user); } }}
方式二：
-
需要给接口加实现类【UserMapperImpl2】
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper { public List<User> selectUser() { return getSqlSession().getMapper(UserMapper.class).selectUser(); }} -
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 https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <import resource="spring-dao.xml"/> <!----> <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl"> <property name="sqlSession" ref="sqlSession"/> </bean> <bean id="userMapper2" class="com.kuang.mapper.UserMapperImpl2"> <property name="sqlSessionFactory" ref="sqlSessionFactory"/> </bean></beans> -
测试：
public class MyTest { @Test public void test() throws IOException { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserMapper userMapper = context.getBean("userMapper2", UserMapper.class); for (User user : userMapper.selectUser()) { System.out.println(user); } }}
13、声明式事务（项目11）
1、回顾事务
- 把一组业务当成一个业务来做；要么都成功，要么都成功，要么都失败！
- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
- 确保完整性和一致性；
事务ACID原则：
- 原子性
- 一致性
- 隔离性
- 多个业务可能操作同一个资源，防止数据损坏
- 持久性
- 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到容器中！
2、spring中的事务管理
-
声明式事务：AOP
-
编程式事务：需要再代码中，进行事务的管理
<?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:tx="http://www.springframework.org/schema/tx" 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/tx https://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid 我们这里使用Spring提供的JDBC：org.springframework.jdbc.datasource --> <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="root"/> </bean> <!--sqlSessionFactory--> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="datasource" /> <!--绑定Mybatis配置文件--> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"/> </bean> <!--SqlSessionTemplate:就是我们使用的sqlSession--> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean> <!--配置声明式事务--> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="datasource"/> </bean> <!--结合AOP实现事务的织入--> <!--配置事务通知：--> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <!--给那些方法配置事务--> <!--配置事务的传播特性：new propagation--> <tx:attributes> <tx:method name="add" propagation="REQUIRED"/> <tx:method name="delete" propagation="REQUIRED"/> <tx:method name="update" propagation="REQUIRED"/> <tx:method name="query" read-only="true"/> <tx:method name="*" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!--配置事务切入--> <aop:config> <aop:pointcut id="txPointCut" expression="execution(* com.kuang.mapper.*.*(..))"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/> </aop:config></beans>
思考：
为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况下；
- 如果我们不在SPRING中去配置声明式事务，我们就需要在代码中手动配置事务！
- 事务在项目的开发中十分重要，设计到数据的一致性和完整性问题，不容马虎！
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
