## spring总结
### 1 、spring
#### 1.1 spring 简介
简化了项目的开发、但配置依然很繁琐！！！
扩展：
SSH：Struct2 + Spring + Hibernate
SSM: SpringMvc +Spring + Mybatis
spring官网：https://spring.io/
spring下载： http://repo.spring.io/libs-release-local/org/springframework/spring/
maven配置：https://mvnrepository.com/
```java
org.springframework
spring-webmvc
5.3.20
org.springframework
spring-jdbc
5.3.20
```
#### 1.2 优点
一句话：Spring就是一个轻量级的控制反转（IOC)和面向切面编程（AOP）的框架
#### 1.3 spring的组成（重要）
#### 1.4 扩展
spring->springboot->springcloud->spring网格
框架的一般原则：约定>配置>编码
学习springcloud要先学springboot、spring、java基础依次类推~~
### 2 、IOC（重要）
原始：程序主动创建对象、控制权在程序员上
spring：使用set注入（lombok简化开发springboot）程序不在具有主动性、而是变成了被动接受的对象！
#### 2.1 IOC的本质
IOC是spring的核心内容！可以使用配置文件（xml）和注解的方式实现IOC、其实现方式是依赖注入（DI）
```java
public class hello(){
private String str;
getter/setter(略)
toString(略)
}
```
```xml
xml:官网复制
```
```
public class testMain(){
public static void main(String[] args){
//获取spring的上下文对象 固定写法
ApplicationContext context = new ClassPathApplicationContext(beans.xml)
//对象都在spring中管理了、我们要使用直接从对象里面取出来 就可以了。
Hello hello = (hello) context.getBean("hello")
System.out.println(hello)
}
}
```
```java
public class testlh(){
public static void main(String[] args){
//获取ApplictionContext:拿到spring的容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//容器在手、天下我有、需要什么get什么
UserServiceImpl userserviceimpl = context.getBean("UserServiceImpl");
userServiceImpl.getUser();
}
}
```
IOC：对象由spring来创建、管理、装配
### 3、spring的创建方式
```java
public class User(){
private String name;
getter/setter
toString
}
```
```java
public class MyTest(){
public static void main(String[] args){
Application context = new ClassPathXmlApplicationContext("beans.xml")
User user = (User) context.getBean("user");
user.show();
}
}
```
```xml
```
IOC创建对象的方式：（重要）
1、使用无参构造创建对象、默认
2、使用有参构造创建对象:三种方式
```xml
```
总结：在配置文件加载的时候、容器中管理的对象就已经开始初始化了！！！
### 4、Spring配置
#### 4.1 别名、配置、import
```xml
```
```java
public class MyTest(){
public static void main(String[] args){
Application context = new ClassPathXmlApplicationContext("beans.xml")
User user = (User) context.getBean("user,u2,u3,u4");
user.show();
}
}
```
### 5、依赖注入（DI)
#### 5.1 构造器注入
#### 5.2 Set注入（重要）
依赖注入：set注入
依赖：bean对象的创建依赖于容器
注入：bean对象中的所有属性、由容器来注入
【环境搭建】
```java
public class Address(){
private String address;
...
}
```
```java
public class Student(){
//各种不同属性的注入方式
private String name;
private Address address;
private String[] books;
private List hobbys;
private Map card;
private Set games;
private String wife;
private Properties info;
}
```
```xml
hahh
youyuio
kafghj
oiuh
lkgjha
ioregh
oaigh
algh
cos
32oriu
2345
jalfkj
```
```java
public class testStudent(){
public static void main(String[] args){
ApplicationContext context = new ClassPathXmlContext("bean.xml");
Student student = (Student)context.getBean("student")
System.out.println(student.getName());
}
}
```
```xml
```
```
p命名空间和c命名空间的使用：
......
```
#### 5.3 bean的作用域
共六种：
1、单列默认（默认）
scope="singleton"
2、原型模式：每此从容器中get的时候、都会产生一个新对象~
scope="prototype"
3、其余的request、session、application、这些都只在web开发中使用！！！
### 6、Bean的自动装配
自动装配是spring满足bean依赖的一种方式。
spring会在上下文中自动寻找、并自动给bean装配属性
在spring中有三种装配的方式
1、在xml中显示的配置
2、在java中显示装配
3、隐式的自动装配bean【重要】
#### 6.1、测试
```java
public class Cat(){
public void shout(){
System.out.println("miao~~~");
}
}
```
```java
public class Dog(){
public void shout(){
System.out.println("wang~~~~");
}
}
```
```java
public class People(){
private Cat cat;
private Dog dog;
private String name;
.......
}
```
```xml
bean.xml:
```
```java
public class test(){
@Test
public void test1(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
People people = context.getBean("people",People.class);
people.getDog().shout();
people.getCat().shout();
}
}
```
#### 6.2、自动装配:autowire(byName、byType)
```xml
bean.xml:
```
#### 6.3、使用注解实现自动装配（重要）
jdk1.5以上支持的注解、spring2.5以上支持注解
要使用注解：
1、导入约束：xml中配置context约束
2、配置注解的支持：context:annotation-config/
```xml
学会自己配置xml配置文件
```
###### @Autowired
直接在属性上使用即可！也可以在set方式上使用。
使用Autowired可以不用编写set方法、前提是自动装配的属性在IOC(Spring)容器中存在，且符合名字byName!
```
@Nullable:字段标记了这个属性、
@Autowired(required=false):required的值为false,说明对象可以为空、否则对象不能为空！！！
@Qualifier(value="dog"):如果自动装配的环境毕节复杂，一个注解无法完成时可以用@Qualifier指定装配多个对象
-------------------
@Resource:结合了名字(name)和类型(type)
```
总结：@Resource和@Autowired的区别？
- 都是用来自动装配的，都可以实现放在属性字段上
- @Autowired通过byType的方式实现、而且必须要求这个对象存在！[常用]
- @Resource默认通过byName的方式实现、如果找不到名字、则通过byType实现、如果两个都找不到就报错！！！
- 执行顺序不同：
- @Autowired 先通过byTpe的方式实现。再通过byName的方式实现
- 如果Autowired不能唯一自动装配实现，则需要通过@Qulifier(value="xxx")来实现
- @Resource 先通过使用byName再通过byType的方式实现！！！
### 7、使用注解开发
在spring4之后、要使用注解开发、必须保证aop的包导入了！！！
需要导入注解的支持~
```xml
```
```java
@Component:组件
@Component
public class User(){
@Value("lihui")
private String name;
或
@Value("lihui")
private void setName(String name){
this.name=name;
}
}
```
#### 1、bean
#### 2、属性如何注入
#### 3、衍生的注解
@Component有几个衍生的注解，我们在web开发中会按照mvc三层架构分层！！
dao：【@Repository】
service：【@Service】
controller:【@Controller】
这四个注解功能一样：都是代表将某个类注入到spring容器中~
#### 4、自动装配
~~~
上面已陈述
~~~
#### 5、作用域
```
@Scope("singleton","property")
```
#### 6、小节
- xml与注解
- xml更加万能，适用于任何场合~，维护相对复杂
- 注解不是自己类使用不了，维护相对复杂
- xml与注解的最佳实践
- xml用来管理bean
- 注解只负责完成属性的注入。
- 在使用的过程中只需要主要一个问题：要让注解生效，必须开启注解的支持和扫描对应的包
- ```
```
### 8、使用java的方式配置spring
不使用spring的xml配置，完全使用java来注解来做~~
javaconfig
```java
//这个注解的意思说明这个类被spring接管了，注册到了容器中。
@Component
public class User(){
@Value("lihui")//属性注入值
private String name;
......
}
```
```java
@Configuration//这个也会被spring容器托管，注册到spring容器中，因为他也是一个组件，代表这是一个配置类，和beans.xml一样的
@ComponentScan("com.lh.pojo")
@Import("lihui.class")//新特性~~~~
public class lihuiConfig(){
//注册一个bean就相当于，我们之前写的一个bean标签
//这个方法的名字，就相当于bean标签中的id属性
//这个方法的返回值，就相当于bean标签中的class属性
@Bean
public User user(){
return new User(); //就是返回要注入到bean的对象~
}
}
```
```java
public class test(){
public static void main(String[] args){
//如果完全使用了配置类方式去做，我们就要通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载~
Application context = new AnnotationConfigApplicationContext(lihui.class);
User getUser =(User) context.getBean("getUser")
System.out.println(getUser.getName());
}
}
```
这个纯java的配置方式，在springboot中随处可见~~~
### 9、AOP(重点)
#### 9.1 代理模式
为啥要学习代理模式？
因为这就是springAop的底层【springAOP和springMVC重要】
代理模式的分类：
~~~~
我---->中介----->买房
~~~~
#### 9.2、静态代理：
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做附属操作
- 客户：访问代理对象的人
```java
//租房接口
public interface Rent(){
public void rent();
}
```
```java
//房东
public class Host implements Rent(){
public void rent(){
System.out.println("房东要出租房子");
}
}
```
```java
public class Client{
public static void main(String[] args){
Host host = new Host();
//代理,代理一般会有一些附属操作~~~
Proxy proxy = new Proxy(host);
proxy.rent();
}
}
```
```java
public class Proxy{
private Host host;
public Proxy(){}
public proxy(Host host){
this.host=host;
}
public void rent(){
host.rent();
}
//看房
public void seeHose(){
System.out.println("中介带你看房");
}
//收中介费
public void fare(){
Syetem.out.println("收中介费");
}
}
```
代理模式的好处：
- 可以是真实角色的操作根据纯粹，不要去关注一些公共的业务
- 公共业务就交给代理角色，实现了业务的分工
- 公共业务发生扩展的时候，方便集中管理
缺点：
代码量翻倍，开发效率较低~~~
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zJL1CTEm-1661669913089)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1661652710109.png)]
#### 9.3、动态代理：
- 动态代理和静态代理一样，
- 动态代理的代理类是动态生成的，不是我们直接写好的
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口----JDK动态代理【建议使用】
- 基于类：cglib
- java字节码实现：javasist
需要了解两个类：Proxy:代理、InvocationHandler:调用处理程序
**InvocationHandler**
```java
//用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandle{
//被代理的接口
private Rent rent;
public void setRent(Rent rent){
this.rent=rent;
}
//生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
}
//处理代理实例，并返回结果
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
//动态代理的本质，就是使用反射机制实现！！！
Object result = method.invoke(rent,args);
return result;
}
//添加
public void seeHose(){
System.out.println("hafgjkllj");
}
}
```
```java
//真实角色
public class true(){
Host host = new Host();
//代理角色
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setRent(host);
Rent proxy = (Rent) pih.getProxy();
proxy.rent();
}
```
动态代理的好处：
- 具有静态代理的所有好处
- 一个动态代理类代理的是一个接口，一般就是对应的一个业务。
- 一个动态代理类可以代理多个类，只有实现了接口。
#### 9.3、AOP(面向多面编程)
#### AOP的实现方式一
```xml
org.aspectj
aspectjweaver
1.9.6
runtime
```
```java
public interface UserService{
public void add();
public void delete();
public void update();
public void select();
}
```
```java
public class UserServiceImpl implements UserService{
public void add(){
sout("...")
}
public void delete(){
sout("...")
}
public void update(){
sout("...")
}
public void select(){
sout("...")
}
}
```
方式一：使用spring的接口【主要是springAPI接口实现】
```java
public class log implements MethOdBeforeAdvice{
//method:要执行的目标对象的方法
//args:参数
//target：目标对象
public void before(Method method,Object[] args,Object target) throws Throwable{
sout(target.getClass().getName()+method.getMethod());
}
}
```
```xml
//注册bean
//配置aop:需要导入aop的约束
//切入点 expression表达式，execution(要执行的位置****)
//执行环绕
//自定义类
//自定义切面 ref要引用的类
//切入点
//通知
//注解实现
```
**注：动态代理代理的是接口，不能代理实现类！！！**
方式二：使用自定义类实现【主要是实现切面】
```java
public class DiyPointCut{
public void before(){
sout("...")
}
public void after(){
sout("...")
}
}
```
方式三：注解实现
```java
@Aspect//标注这是一个切面
public class AnnotationPointCut{
@Before("execution(* com.lh.UserserviceImpl*(..))")
public void before(){
sout("....")
}
}
```
### 10、整合Mybatis
步骤：
1、导入相关jar包
- junit
- mybatis
- mysql
- spring相关
- aop织入
- mybatis-spring【new package】
```xml
...
```
2、编写配置文件
3、测试
#### 10.1、回顾mybatis
步骤：
- 编写实体类
```java
@Data
public class User(){
private String name;
private Integer age;
}
```
- 编写核心配置文件
```xml
```
- 编写接口
```java
public interface UserMapper(){
public List selectUser();
}
```
- 编写mapper.xml
```xml
select *from mybatis.user;
```
- 测试
```java
public class mytest(){
@Test
public void test(){
String resources ="mybatis-config.xml";
Resources input = Resources.getResourcesAsStream(resources);
......
}
}
```
#### 10.2 mybatis-spring
整合mybatis的方式一：
```java
org.mybatis
mybatis-spring
2.0.6
```
```xml
//DataSource:使用spring的数据源替换mybatis的配置 c3p0 dbcp druid
//使用spring直接提供的JDBC
```
整合mybatis的方式二：（略）
### 11、声明式事务
#### 1、事务？
- 把一组业务当做一个业务来做，要么成功，要么失败！
- 事务在项目开发中，十分重要，设计到数据的一致性问题，不可马虎~~
- 确保完整性和一致性
事务的ACID原则：
- 原子性
- 一致性
- 隔离性
- 多个事务可能操作同一个资源，防止数据损坏
- 持久性
- 事务一旦提交，无论系统发生什么问题，结果都不在被影响。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！ |
