Spring5.0學習知識總結-有解無憂

## 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/
![在這里插入圖片描述](https://img-blog.csdnimg.cn/c3e91a155ab74f84907acde844fb6a81.png#pic_center)
```java

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.20</version>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.20</version>
</dependency>
```

#### 1.2 優點

一句話：Spring就是一個輕量級的控制反轉（IOC)和面向切面編程（AOP）的框架

#### 1.3 spring的組成（重要）

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vaGFveXVubHdoL1R5cG9yYWltYWdlL3Jhdy9tYXN0ZXIvaW1nLzIwMjAwODIxMDc1NDM4LnBuZw?x-oss-process=image/format,png)

#### 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:官網復制
<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">


<bean id="hello" calss="com.pojo.hello">
<property name="str" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/Spring"></property>
</bean>

</beans>

```

```
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();
}
}
```

IOC創建物件的方式：（重要）

1、使用無參構造創建物件、默認

2、使用有參構造創建物件:三種方式

總結：在組態檔加載的時候、容器中管理的物件就已經開始初始化了！！！

### 4、Spring配置

#### 4.1 別名、配置、import

```

### 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<String> hobbys;
private Map<String,Sring> card;
private Set<String> games;
private String wife;
private Properties info;
}

```

```xml
<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">

<bean id="student" >
<property name="name" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/lihui"></property>
</bean>

<bean id="address" ></bean>

<property name="books">
<arrar>
<value>hahh</value>
<value>youyuio</value>
<value>kafghj</value>
<value>oiuh</value>
</arrar>
</property>

<property name="list">
<list>lkgjha</list>
<list>ioregh</list>
<list>oaigh</list>
</property>

<property name="map">
<map>
<entry key="id" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/h1234"></entry>
<entry key="akfg" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/dlakgh"></entry>
</map>
</property>

<property name="set">
<set>
<value>algh</value>
<value>cos</value>
<value>32oriu</value>
</set>
</property>

<property name="wife">
<null></null>
</property>

<property name="info">
<props>
<prop key="ihi">2345</prop>
<prop key="afskl">jalfkj</prop>
<prop key="weil"></prop>
<prop key="aklegja"></prop>
</props>
</property>
<beans>
```

```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());
}
}
```

```
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:
<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">

<bean id="cat" ></bean>
<bean id="dog" ></bean>
<bean id="people" >
<property name="name" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/lihui"></property>
<property name="dog" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/dog"></property>
<property name="cat" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/cat"></property>
</bean>

</beans>
```

```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:
<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">

<bean id="cat" ></bean>
<bean id="dog" ></bean>

<bean id="people" autowire="byName" autowire="byType">
<property name="name" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/lihui"></property>
</bean>

</beans>
```

#### 6.3、使用注解實作自動裝配（重要）

jdk1.5以上支持的注解、spring2.5以上支持注解

要使用注解：

1、匯入約束：xml中配置context約束

2、配置注解的支持：context:annotation-config/

```

###### @Autowired

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

使用Autowired可以不用撰寫set方法、前提是自動裝配的屬性在IOC(Spring)容器中存在，且符合名字byName!

```
@Nullable:欄位標記了這個屬性、
@Autowired(required=false):required的值為false,說明物件可以為空、否則物件不能為空！！！
@Qualifier(value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/dog"):如果自動裝配的環境畢節復雜，一個注解無法完成時可以用@Qualifier指定裝配多個物件
-------------------
@Resource:結合了名字(name)和型別(type)
```

總結：@Resource和@Autowired的區別？

- 都是用來自動裝配的，都可以實作放在屬性欄位上
- @Autowired通過byType的方式實作、而且必須要求這個物件存在！[常用]
- @Resource默認通過byName的方式實作、如果找不到名字、則通過byType實作、如果兩個都找不到就報錯！！！
- 執行順序不同：
- @Autowired 先通過byTpe的方式實作，再通過byName的方式實作
- 如果Autowired不能唯一自動裝配實作，則需要通過@Qulifier(value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/xxx")來實作
- @Resource 先通過使用byName再通過byType的方式實作！！！

### 7、使用注解開發

在spring4之后、要使用注解開發、必須保證aop的包匯入了！！！

需要匯入注解的支持~

```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

- 注解只負責完成屬性的注入，

- 在使用的程序中只需要主要一個問題：要讓注解生效，必須開啟注解的支持和掃描對應的包

- ```

<context component-scan="com.lh.pojo"/>
<context:annotation-config></context:annotation-config>
```

### 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

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
<scope>runtime</scope>
</dependency>

```

```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
<bean id="userService" >
</bean>
//配置aop:需要匯入aop的約束
<aop:config>
//切入點 expression運算式，execution(要執行的位置****)
<aop:pointcut id="pointcut" expression="execution(要執行的位置！*****)"></aop:>
//執行環繞
<aop:advisor advice-ref="afterLog"></aop:>
</aop:config>

//自定義類
<bean id="diy" calss="com.lh.diy.DiyPointCut"></bean>
<aop:config>
//自定義切面 ref要參考的類
<aop:aspect ref="diy">
//切入點
<aop:pointcut id="point" expression="execution(* com.lh.service.UserServiceImpl.*(..))">
//通知
<aop:before method="before" pointcut-ref="point"></aop:>
</aop:>
</aop:>
</aop:config>

//注解實作
<aop:aspectj-autoproxy proxy-target-></aop:aspectj-autoproxy>

```

**注：動態代理代理的是介面，不能代理實作類！！！**

方式二：使用自定義類實作【主要是實作切面】

```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
<dependencies>
...<略>
</dependencies>

```

2、撰寫組態檔

3、測驗

#### 10.1、回顧mybatis

步驟：

- 撰寫物體類

```java
@Data
public class User(){
private String name;
private Integer age;
}

```

- 撰寫核心組態檔

```xml
<typeAliases>
<package name="com.lh.pojo"></package>
</typeAliases>

<environments default="development">
<environment id="development">
<transactionManager type="JDBC"> </transactionManager>
<dataSource type="POOLED">
<property name="driver" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/com.mysql.cj.jdbc.Driver"></property>
<property name="url" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/xxx"></property>
<property name="username" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/xxx"></property>
<property name="password" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/xxx"></property>
</dataSource>
</environment>
</environments>

<mappers>
<mapper > </mapper>
</mappers>

```

- 撰寫介面

```java
public interface UserMapper(){
public List<User> selectUser();
}

```

- 撰寫mapper.xml

```xml
<mapper namespace="com.lh.mapper.UserMapper">
<select id="selectUser" resultType="user">
select *from mybatis.user;
</select>
</mapper>

```

- 測驗

```java
public class mytest(){
@Test
public void test(){
String resources ="mybatis-config.xml";
Resources input = Resources.getResourcesAsStream(resources);
......
}
}

```

#### 10.2 mybatis-spring

整合mybatis的方式一：

```java

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.6</version>
</dependency>

```

```xml
//DataSource:使用spring的資料源替換mybatis的配置 c3p0 dbcp druid
//使用spring直接提供的JDBC
<bean id="datasource" >
<property name="driverClassName" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/xxx"></property>
<property name="url" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/xxx"></property>
<property name="username" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/xxx"></property>
<property name="password" value="https://www.cnblogs.com/lihui-qianying/archive/2022/08/28/xxx"></property>
</bean>

<bean id="sqlSessionFactory" >
<property name="" value=""></property>
<property name="" value=""></property>
</bean>

```

整合mybatis的方式二：（略）

### 11、宣告式事務

#### 1、事務？

- 把一組業務當做一個業務來做，要么成功，要么失敗！
- 事務在專案開發中，十分重要，設計到資料的一致性問題，不可馬虎~~
- 確保完整性和一致性

事務的ACID原則：

- 原子性
- 一致性
- 隔離性
- 多個事務可能操作同一個資源，防止資料損壞
- 持久性
- 事務一旦提交，無論系統發生什么問題，結果都不在被影響，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/502976.html

標籤：其他

上一篇：行程、執行緒補充與協程相關介紹

下一篇：Pytest框架 — 16、Pytest的測驗報告（pytest-html插件和Allure框架）