Spring5--IOC

 

簡介

   spring已經成爲了java開發人員必備的框架，spring基本引領着整個java開發方向的流程，現在spring提供了五花八門的模塊來幫助開發人員進行各種java項目的構建，在spring5中提出了非阻塞的web框架。

Spring的安裝

   Spring的安裝非常的簡單，只要使用在maven中引入相應的java即可完成安裝

<dependencies>
       <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>5.0.8.RELEASE</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-core</artifactId>
           <version>5.0.8.RELEASE</version>
       </dependency>

   </dependencies>

下面我們創建一個Spring的java文件，在Spring4之後，就可以使用基於Annotation的方式來完全替換原有的xml的方法，但是我們這部分的內容會兩個方式都簡單進行介紹。我們首先通過基於Annotation的方式來創建一個Spring的項目，以此驗證spring是否安裝成功。

@Configuration
public class HelloSpringConfig {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(HelloSpringConfig.class);
        String hello = applicationContext.getBean("hello", String.class);
        System.out.println(hello);
    }
    @Bean("hello")
    public String getHello(){
     return "hello world Spring5";
    }
}

@Configuration聲明的類就表示該類是一個配置類，就等於原來的beans.xml文件，類中的方法getHello上使用@Bean，這說明該方法會返回一個String類型的對象。在main方法中通過AnnotationConfigApplicationContext 將該配置文件加載進去到spring的上下文中，spring的上下文就等於一個大容器，spring通過這個容器來管理所有的對象，通過getBean方法可以獲取剛纔創建的bean，然後輸出結果。

以上程序將會輸入hello這個字符串，只要能運行成功說明spring 的環境已經正確的安裝完成，下面我們將介紹spring 的IOC的作用和意義。

IOC介紹

OC是控制反轉，它是spring非常重要的一個特性，它是spring學習的基礎，Ioc也成爲DI（依賴注入），簡單來說就是把spring變成一個容器，由spring來控制對象的創建和他們之間的依賴關係，下面我們通過一個實例來給大家講解spring的IOC的使用和意義。

用簡單的java代碼演示，爲什麼使用IOC?

  java代碼十分簡單

   Knight:

public class Knight {
    private String username;
    private Weapon weapon;

    public Knight(String username,Weapon weapon) {
        this.username = username;
        this.weapon = weapon;
    }
    //省略了getter和setter
    public void fight() {
        weapon.attack();
    }

  和Weapon相關的代碼

public interface Weapon {
    void attack(String name);
}

public class Axe implements Weapon {
    public void attack(String name) {
        System.out.println(name+"提起斧頭，向人砍去");
    }
}

public class Gun implements Weapon {
    public void attack(String name) {
        System.out.println(name+"用槍打你啊");
    }
}

public class Knife implements Weapon{
    public void attack(String name) {
        System.out.println(name+"提着大刀，看人去");
    }
}

下面就是Knight中如何創建Weapon的問題，最原始的方案就是在使用new來創建具體的Weapon實例

public class Test {
   public static void main(String[] args){
       Weapon w = new Axe();
       Knight tom = new Knight("tom", w);
       tom.fight();
   }
}

這種方案最大的問題就是依賴於一個具體的實現類，將來如果要修改Weapon的實現類所有的代碼都需要調整，喪失了靈活性，第二種方案是基於工廠的模式來創建，這裏使用簡單工廠來演示。

public class SimpleFactory {
    public static Weapon getWeapon() {
        return new Knife();
    }
}


public class Test {
   public static void main(String[] args){
      /* Weapon w = new Axe();
       Knight tom = new Knight("tom", w);
       tom.fight();*/
       Weapon weapon = SimpleFactory.getWeapon();
       Knight tom = new Knight("tom", weapon);
       tom.fight();
   }
}

這種方案將來如果希望修改Weapon的實現類只要修改一個地方即可，這種方法雖然解決了靈活性的問題，但將來修改的時候需要調整源代碼，所以這種方式也不是很理想，最佳的方案是將具體的類寫到一個配置文件中，通過讀取配置文件來創建具體的對象。創建一個factory.properties文件來存儲具體的對象

weapon = com.el.spring5.Gun

爲了方便確定那些對象需要創建，可以自己定義一個Annotation來指定要創建的對象

@Retention(RUNTIME)
public @interface Inject {
    public String value() default "";
}

然後在需要創建的對象的setter方法上添加該Annotation

@Inject
public void setWeapon(Gun weapon) {
  this.weapon = weapon;
}

讓所有需要添加這個對象的類繼承於一個基類，在這個基類中來創建所有的對象

ublic class Base {
    public Base() {
        try {
            Properties prop = new Properties();
            prop.load(Base.class.getClassLoader()
                    .getResourceAsStream("factory.properties"));
            //通過反射來讀取需要創建對象的信息
            Method[]ms =  this.getClass().getDeclaredMethods();
            for(Method m:ms) {
                if(m.isAnnotationPresent(Inject.class)) {
                    Inject in = m.getAnnotation(Inject.class);
                    String name = null;
                    //獲取對象key
                    if("".equals(in.value())) {
                        //沒有指定，就默認通過setXXX方法來處理，把set去掉，然後第一個字母小寫
                        name = m.getName();
                        name = name.substring(3);
                        name = name.substring(0, 1).toLowerCase()+name.substring(1);
                    } else {
                        name = in.value();
                    }
                    String o = prop.getProperty(name);
                    if(o!=null) {
                        //創建對象
                        Object obj = Class.forName(o).newInstance();
                        //調用方法創建對象
                        m.invoke(this, obj);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Base是所有需要創建對象的基類，此處Knight需要繼承於Base這個基類，只要創建Knight，就會自動調用父類不帶參數的構造方法來完成對象的注入。這就是依賴注入的一種通過這種方式，只要繼承於Base這個類的所有類，都支持這種依賴注入的方式，這就是spring的DI所做的事情，spring提供了一個大容器來管理所有的對象依賴，接下來我們首先通過spring的xml配置文件來完成同樣的操作。

基於xml的配置方式

首先在資源文件中創建beans.xml，並且引入spring的schema

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

在該文件中可以直接創建具體的對象和依賴關係

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="weapon" class="com.el.spring5.Knife"/>
    <bean id="knight" class="com.el.spring5.Knight">
        <property name="weapon" ref="weapon"/>
    </bean>

</beans>

創建了兩個bean，一個是weapon，weapon的類型是Knife，另外一個是knight，其中knight依賴於weapon，接着只要通過spring的ApplicationContext來創建對象就會被spring所管理。

 public static void main(String[] args) {
       ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
       Knight k = (Knight)ctx.getBean("knight");//根據beans.xml中的id來獲取對象
       k.fight();
   }

在spring3之後就提供了基於Annotation的方式來進行對象的管理，這樣可以簡單大量的配置操作。

基於Annotation的方式

  首先在beans.xml中開啓Annotation的支持，並且設定需要掃描的包，需要加入context的schema

<?xml version="1.0" encoding="UTF-8"?>
<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
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <context:annotation-config/>
    <context:component-scan base-package="com.el.spring5.annotation.*"/>
</beans>

之後在需要spring管理對象中添加@Component的Annotation，在需要注入的對象的setter方法上添加@Autowired,首先看看幾種武器的設置

 

@Component("axe")
public class Axe implements Weapon {
    ...
}
@Component("gun")
public class Gun implements Weapon {
    ...
}
@Component("knife")
public class Knife implements Weapon {
    ...
}

這裏創建了三個對象axe,gun和knife，但是此時Knight的setWeapon使用了@Autowired進行注入，由於方法是setWeapon，所以會找weapon的對象，顯然沒有，此時需要指定要注入的對象類型,使用@Qualifier來進行設定

@Component("knight")
public class Knight {
    private String username;
    private Weapon weapon;
    ...
    @Autowired
    @Qualifier("axe")
    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

main函數的代碼不用進行任何修改，可以直接運行。在spring4之後提供了基於java的配置方式，此時連xml 文件都不需要，下面就來看看這種方式

基於java配置文件的方式

 在spring的新版本中，提供純java的支持方式，此時甚至都不需要添加如何的xml文件，但需要專門創建一個java的配置類，在該類上增加一些配置說明。

@Configuration
@ComponentScan("com.el.spring5")
public class BaseConfiguration {
}

 

其他的類的設定不變，最後在調用的時候有一些基本的區別。

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(BaseConfiguration.class);
        Knight k = (Knight)ctx.getBean("knight");
        k.fight();
        ((AnnotationConfigApplicationContext)ctx).close();
    }
}

以上內容就是spring的IOC的主要內容，IOC是spring的最基礎，它讓所有的類被spring所管控，這樣spring就可以非常方便的爲開發人員提供各種功能。