今天完成的事情

1.讲了小课堂，spring IOC
在面向对象编程中，其基本思路是实现对象之间的低耦合，高内聚，而在传统的Java代码编写中，如果有某个对象A依赖于其他对象B，在使用时，需要先创建所依赖的对象B，传入对象A，然后才能对对象A进行操作，这种方式提高了代码的耦合度，十分不利于重构和维护
采用spring的依赖注入，可以促进代码的松散耦合。借助这种方式，对象无需知道依赖来自何处，或者依赖的实现方式，确保了低耦合
传统方式，需要先用new关键词，或者是通过工厂类来创建一个所依赖的对象，传入当前对象：

public class T2 {
    
private T1 t1;
    
public void setT1(T1 t1) {
        this.t1 = t1;
    }
    
private String p1 = "this is T2: ";
    
public void print(){
        
System.out.println(p1);
        
t1.print();
    }
}

如上，T2类依赖于T1类，当需要调用T2的方法时，需要先创建T1对象：

 @Test
    
public void testT2_T1(){
        
T1 t1 = new T1();
        
T2 t2 = new T2();
        
t2.setT1(t1);
       
 t2.print();
    }

IOC，Inversion of Control，控制反转，不是什么技术，而是一种设计思想，它包括依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。在Java开发中，Ioc意味着将设计好的对象交给容器控制，而不是传统的在对象内部直接控制
DI—Dependency Injection，即“依赖注入”
需要理解一下几个问题：
谁依赖于谁：当然是应用程序依赖于IoC容器
为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源
谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象
注入了什么：就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)

spring提供了三种主要的方式来配置
1.在XML中进行显式配置
2.在Java中进行显式配置，JavaConfig
3.隐式的bean发现机制和自动装配

1.在XML中配置

类：

public class C1 {
    
private String p1;
    
private String p2;
    
public void setP1(String p1) {
        this.p1 = p1;
    }
    
public void setP2(String p2) {
        this.p2 = p2;
    }
    
public void print(){
        System.out.println("this is C1: "+p1+p2);
    }
    
public C1() {
    }
    
public C1(String p1, String p2) {
        this.p1 = p1;
        this.p2 = p2;
    }
}

在xml配置文件中配置：

 <bean id="c1" class="xml.C1">
        
<property name="p1" value="Hello"/>
        
<property name="p2" value="Xml"/>
    
</bean>

如果类依赖了其他对象:

public class C3 {
    
private C1 c1;
    
public void setC1(C1 c1) {
        this.c1 = c1;
    }
    
public void print(){
        
System.out.print("this is C3: ");
        
c1.print();
    }
}

则需要进行装配：

<bean id="c3" class="xml.C3">
        
<property name="c1" ref="c1"/>
    
</bean>

2.在Java中进行显式配置

public class B1 implements B{
    
private String p1;
    
private String p2;
    
public void setP1(String p1) {
        this.p1 = p1;
    }
    
public void setP2(String p2) {
        this.p2 = p2;
    }
    
public void print(){
        System.out.println("this is B1: "+p1+" "+p2);
    }
}

B3依赖B1

public class B3 implements B{
    
private B1 b1;
    
public B3(B1 b1) {
        this.b1 = b1;
    }
    
public void print(){
        
System.out.print("this is B3: ");
        
b1.print();
    }
}

创建一个配置类，使用注解@Configuration标注为配置类，bean会在此处装配：

@Configuration
public class Config {
    
@Bean
    
public B1 b1(){
        
B1 b1 = new B1();
        
b1.setP1("Hello");
        
b1.setP2("JavaConfig");
        
return b1;
    }
   
 @Bean
    
public B3 b3(B1 b1){
       
 return new B3(b1);
    }
}

3.隐式的bean发现机制和自动装配
需要开启组件扫描：

@Configuration
@ComponentScan
public class Config {
}

只需要在原有的类上添加注解即可：

@Component 
public class A1 implements A{
    
@Value("Hello")
    
private String p1;
    
@Value("World")
    
private String p2;
    
public void print(){
        
System.out.println("this is A1: "+p1+" "+p2);
    }
}

A3依赖A1

@Component
public class A3 implements A{
    
private A1 a1;
    
@Autowired
    
public A3(A1 a1) {
        this.a1 = a1;
    }
    
public void print(){
        
System.out.print("this is A3: ");
        
a1.print();
    }
}

注解 @Autowired实现自动装配

2.看了一些复盘资料，还不太懂

明天的计划

看看AOP，研究复盘项目

遇到的问题

无

收获

对IOC又有了一些理解，以前理解得不够