欧美日韩中出,日韩日本字幕,久久久久88色偷偷

spring已經(jīng)成為了java開發(fā)人員必備的框架，spring基本引領(lǐng)著整個java開發(fā)方向的流程，現(xiàn)在spring提供了五花八門的模塊來幫助開發(fā)人員進行各種java項目的構(gòu)建，在spring5中提出了非阻塞的web框架。這里將會從頭開始講解spring5的一些比較重要的知識，這一講將會主要介紹Spring 的IOC。

Spring的安裝

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

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>5.0.2.RELEASE</version>
</dependency>

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

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

    @Bean("hello")
    public String getHello() {
        return "hello";
    }
}

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

以上程序?qū)斎雋ello這個字符串，只要能運行成功說明spring 的環(huán)境已經(jīng)正確的安裝完成，下面我們將介紹spring 的IOC的作用和意義。

IOC介紹

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

我們希望做一個簡單的游戲，這個游戲中有一個戰(zhàn)士(Knight)，戰(zhàn)士有不同的武器可以戰(zhàn)斗，我們通過java的代碼來實現(xiàn)，類圖如下圖所示

Ioc介紹類圖

java代碼非常簡單

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相關(guān)的代碼

public interface Weapon {
    void attack();
}

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

public class Knife implements Weapon {
    public void attack() {
        System.out.println("提著大刀向敵人劈去");
    }
}

public class Gun implements Weapon {
    public void attack() {
        System.out.println("噠噠噠噠噠!");
    }
}

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

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

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

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

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

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

weapon = org.konghao.spring.original.Gun

為了方便確定那些對象需要創(chuàng)建，可以自己定義一個Annotation來指定要創(chuàng)建的對象

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

然后在需要創(chuàng)建的對象的setter方法上添加該Annotation

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

讓所以需要添加這個對象的類繼承于一個基類，在這個基類中來創(chuàng)建所有的對象

public class Base {
    public Base() {
        try {
            Properties prop = new Properties();
            prop.load(Base.class.getClassLoader()
                    .getResourceAsStream("org/konghao/spring/original/factory.properties"));
            //通過反射來讀取需要創(chuàng)建對象的信息
            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) {
                        //創(chuàng)建對象
                        Object obj = Class.forName(o).newInstance();
                        //調(diào)用方法創(chuàng)建對象
                        m.invoke(this, obj);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

基于xml的配置方式

首先在資源文件中創(chuàng)建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>

在該文件中可以直接創(chuàng)建具體的對象和依賴關(guān)系

<?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="org.konghao.spring.xml.Knife"/>
    <bean id="knight" class="org.konghao.spring.xml.Knight">
        <property name="weapon" ref="weapon"/>
    </bean> 
</beans>

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

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

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

基于Annotation的方式

首先在beans.xml中開啟Annotation的支持，并且設(shè)定需要掃描的包，需要加入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="org.konghao.spring.annotation.*"/>
</beans>

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

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

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

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

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

基于java配置文件的方式

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

@Configuration
@ComponentScan("org.konghao.spring.java")
public class BaseConfiguration {
}

其他的類的設(shè)定不變，最后在調(diào)用的時候有一些基本的區(qū)別。

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

以上內(nèi)容就是spring的IOC的主要內(nèi)容，IOC是spring的最基礎(chǔ)，它讓所有的類被spring所管控，這樣spring就可以非常方便的為開發(fā)人員提供各種功能，下一部分看spring的另外一個重要的功能，AOP。

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

spring5入門與實踐第一講Spring 的IOC

spring5入門與實踐第一講Spring 的IOC

Spring的安裝

IOC介紹

基于xml的配置方式

基于Annotation的方式

基于java配置文件的方式

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

spring5入門與實踐第一講Spring 的IOC

Spring的安裝

IOC介紹

基于xml的配置方式

基于Annotation的方式

基于java配置文件的方式

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av