Spring学习之IOC

1：Spring是一个开源的控制反转和面向切面的容器框架，这也是spring核心的两个部分。

所谓的控制反转(IOC)：就是应用本身不负责依赖对象的创建和维护，依赖对象的创建和维护是由外部容器负责的，这样控制权就由应用转移到了外部容器

依赖(DI)注入是什么？是指在运行期间，由外部容器动态的将依赖对象注入到组件中去

面向切面编程(AOP)：扩展功能不是通过修改源代码来实现的

2:IOC与DI联系：

依赖注入是不能单独存在，需要在IOC的基础上来进行操作

3：spring是一站式框架：

spring在javaee三层结构中，每一层都提供不同的解决技术

-web层：SpringMVC

-service层：spring的ioc

-dao：spring的jdbcTemplate

4：IOC操作的两部分：

1）：IOC的配置文件方式

2）：IOC的注解方式

5：IOC的底层原理

1）：xml配置

2）：dom4j解析xml

3）：工厂设计模式

4）：反射

原始调用一个类中的方法，应该这样写：

public class User{
   public void add(){} //定义了一个方法
}

//在service中调用User类的add方法
User user=new User();
user.add();

但是存在一个问题，那就是耦合度太高了，所以就出现了用工厂模式来解耦合：

public class UserService{
   public void add(){};
}

public class UserServlet{
   UserService s=Factory.getService();
}

//创建工厂类
public class Factory{
   public static UserService getService(){
   return new UserService();
   }
}

使用工厂模式又会出现一个新的问题，那么就是servlet跟工厂的耦合度太高了，所以就使用IOC来解决这些问题。

IOC就是把new对象的任务交给容器来解决

public class UserService{
  public void add();
}

public class UserServlet{
   //得到UserService的对象
   //原始：new创建
  ③：Factory.getService();
  
}

①：//创建xml配置文件
<bean id="UserService" class="类路径"/>

②：创建一个工厂类，使用dom4j来解析xml，+反射
public class Factory{
   //返回UserService的对象
   public static UserService getService(){
   //根据id的值，来得到id值所对应class属性值
      String classValue=class属性值
      class c=Class.forName(classValue);
      //创建类对象
      UserService s=c.newInstance();
      return s;
  }
}

6：bean实例化（在Spring中通过配置文件来创建对象）的三种方式

1）：使用类的无参构造创建：类中没有无参的构造方法会出现异常

 org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'user' defined in class path resource [spring-config.xml]: Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.example.entiy.User]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.example.entiy.User.<init>()

2）：使用静态工厂创建：创建一个静态方法，返回类对象

（1）：实体类

public class Bean2 {
    public void add(){
        System.out.println("bea2 add...");
    }
}

（2）：xml配置：

 <bean id="bean2" class="com.Bean2.Bean2Factory" factory-method="getBean2"></bean>

（3）：工厂类

public class Bean2Factory {
    //静态方法，返回Bean对象
    public static Bean2 getBean2(){
        return new Bean2();
    }
}

（4）：单元测试

public class Bean2Test {
    @Test
            public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        Bean2 bean2 = (Bean2) context.getBean("bean2");
        System.out.println(bean2);
        bean2.add();
    }
}

3）：使用实例工厂创建：创建不是静态的方法，返回类对象

（1）：实体类

public class User {
    private void add(){
        System.out.println("bean3 add...");
    }
}

（2）：工厂类

public class Bean3Factory {

    //普通的方法，返回bean3
    public User getUser(){
        return new User();
    }
}

（3）：xml配置

    <!--先创建工厂对象-->
    <bean id="bean3Factory" class="com.Bean3.Bean3Factory"></bean>
    <bean id="bean3" factory-bean="bean3Factory" factory-method="getUser"></bean>

（4）：单元测试

public class bean3Test {
    @Test
    public void test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        User user=(User) context.getBean("bean3");
        System.out.println(user);
    }
}

猜你喜欢