Spring框架介绍以及核心思想

Spring框架介绍

1. Spring核心

   1. AOP:面向切面编程，扩展功能但不修改代码；—>核心是动态代理
   2. IOC：控制反转，降低耦合度。如果调用一个类中的方法，需要new对象后才可调用；在Spring的IOC中，可以将代码new对象的操作交给Spring的配置文件来完成；

2. 一站式框架
   Spring在JavaWeb三层结果中，每一层都提供了不同的解决技术

   1. Web层：SpringMVC 取代Servlet
   2. Service层：Spring ioc
   3. Dao层： Spring jdbc Template 取代jdbc；但是已经过时了，大多数已经使用mybatis来取代jdbc；

3. 框架图
   

Spring的核心思想

在传统的web编程中，Service类需要new一个Dao实例，Servlet类中要new一个Service实例。在使用的过程如果遇到需要更换Dao类，则所有的Service类new的Dao实例都需要手动地去一个个的修改，同样，如果需要更换Service类，那么所用的创建的Service实例的语句都需要进行修改，这样的话太麻烦。有没有一种方法可以不修改代码而能够实现这些类的更换呢？

配置文件Bean.properties，里面存放了需要创建的实例的类的全路径

userService=com.young.service.impl.UserServiceImpl
userDao=com.young.dao.impl.UserDaoImp

创建一个User类

public class User {

     private Integer id;
     private String name;
     private Integer age;

     public User() {
          super();
     }

     public User(Integer id, String name, Integer age) {
          super();
          this.id = id;
          this.name = name;
          this.age = age;
     }

     public Integer getId() {
          return id;
     }

     public void setId(Integer id) {
          this.id = id;
     }

     public String getName() {
          return name;
     }

     public void setName(String name) {
          this.name = name;
     }

     public Integer getAge() {
          return age;
     }

     public void setAge(Integer age) {
          this.age = age;
     }

     @Override
     public String toString() {
          return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
     }    
}

创建UserDao接口

public interface UserDao {
     User getUser(int id);
}

创建UserDao的实现类UserDaoImpl

public class UserDaoImpl implements UserDao {
     @Override
     public User getUser(int id) {
          User user = null;
          switch(id) {
              case 1:
                   user = new User(1,"张三",18);
                   break;
              case 2:
                   user = new User(2,"转给你",19);
                   break;
              case 3:
                   user = new User(3,"发撒而是",548);
                   break;
          }
          return user;
     }
}

创建factory工长，它的作用是通过传来的key获取配置文件中的值，用这个值进行实例的创建，并返回

    public class BeanFactory {
     private static Properties properties;
     
     static {
          InputStream in;
          properties = new Properties();
          try {
              properties.load(BeanFactory.class.getClassLoader().getResourceAsStream("Bean.properties"));
          } catch (IOException e) {
              e.printStackTrace();
         }
     }


     public static <T> T getInstance(String key) {
          String clazz = properties.getProperty(key);
          Class cls;

          try {
              if(null != clazz) {
                   cls = Class.forName(clazz);
                   return (T) cls.newInstance();
              }else {
                   return null;
              }
          } catch (Exception e) {
              e.printStackTrace();
          }
          return null;
     }
}

创建UserService接口

public interface UserService {

     public User getUserById(int id);

}

创建UserService接口的实现类UserServiceImpl

public class UserServiceImpl implements UserService{
    // 通过传key到factory工厂中，创建实例
     UserDao userDao = BeanFactory.getInstance("userDao");

     @Override
     public User getUserById(int id) {
          return userDao.getUser(id);
     }
}

创建UserServlet类

public class UserServlet {
   // 通过传key到factory工厂中，创建实例
     UserService userService = BeanFactory.getInstance("userService");

     public User getUSer(int id) {
        return userService.getUserById(id);
     }
}

测试

public class Test {

     public static void main(String[] args) {
          Integer id = 1;
          UserServlet users = new UserServlet();
          User user = users.getUSer(id);
          System.out.println(user);
     }
}

IOC/DI解耦合及实现原理

IOC—>控制反转（Inversion Of Control）
DI—>注入依赖（Dpendency Injection）