2019-05-23Spring入门

作者: 果冻_4c9b | 来源:发表于2019-05-26 14:12 被阅读0次

Spring是一个管理Bean的容器，一个轻量级框架

使用Spring,需要引入对应的依赖下载地址
prom.xml

 <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <springFramework.version>5.1.5.RELEASE</springFramework.version>
    </properties> 
    <dependencies>
        <!-- spring相关 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${springFramework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${springFramework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springFramework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${springFramework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${springFramework.version}</version>
        </dependency>
        <!--日志-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>2.10.0</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

管理对象，必须是一个接口一个实现类

/**
 * 战士
 */
public interface Fighter {
    void show();
}

/**
* 吕布，战士类的一个实现类
*/
public class LvBu implements Fighter {
    public void show() {
        System.out.println("战士吕布");
    }
}

IOC控制反转/DI依赖注入

回顾历史

之前我们创建对象的方式，是在一个类中主动new另一个类的对象，然后再调用其方法完成功能

public class Main {
    public static void main(String[] args) {
        // 获取对象 -- 以前的方式，主动创建
        Fighter f1 = new LvBu();
        f1.show();
    }
}

Main类掌握着Fighter类型对象的控制权（想创建就创建），这样带来一个缺点，当许多模块都需要使用Fighter类型对象时，一旦Fighter类型对象需要发生改变，需要大量的修改其他模块的代码才能满足需求，所以，Spring提出了一种新的获取对象的方式 -- 配置

spring配置文件

spring.xml

<?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-3.0.xsd">

    <!--配置一个对象-->
    <!--LvBu lvbu = new LvBu();-->
    <bean id="lvbu" class="com.neuedu.test.LvBu"></bean>
    <bean id="guanyu" class="com.neuedu.test.GuanYu"></bean>

</beans>

public class Main {
    public static void main(String[] args) {
        // 获取对象 -- 以前的方式，主动创建
//        Fighter f1 = new LvBu();
//        f1.show();

        // Spring的方式获取对象，需要把对象配置在xml文件中
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Fighter lvbu = (Fighter)applicationContext.getBean("lvbu");
        Fighter guanyu = (Fighter)applicationContext.getBean("guanyu");
        lvbu.show(); // 战士吕布
        guanyu.show(); // 战士关羽
    }
}

使用配置的方式带来一个好处，当Fighter类型对象需要改变的时候，我们只需要修改spring.xml就可以了，不需要修改其他模块，便利了开发

IOC控制反转

对于java应用程序来说，对象的控制权逆转了，这个概念称为IOC--控制反转

DI依赖注入

对于spring来说，配置一个对象，相当于对其他调用者注入了一个可调用的对象

IOC控制反转和DI依赖注入没有区别，只是针对参照物不同的不同说法

属性注入

构造器注入（前提：必须有有参构造器）

<!--默认是调用无参构造器创建对象的，若没有无参构造器，会报错-->
<bean id="guanyu" class="com.neuedu.test.GuanYu"></bean>

public class GuanYu implements Fighter {
    private String name;
    private int age;
    public GuanYu() {}
    public GuanYu(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show() {
        System.out.println(name+","+age);
    }
}

<!--利用有参构造器进行属性注入-->
<bean id="guanyu" class="com.neuedu.test.GuanYu">
    <!--构造器注入属性-->
    <!--给对象的name属性，赋值“关羽”-->
    <constructor-arg name="name" value="关羽"></constructor-arg>
    <!--给对象的age属性，赋值14-->
    <constructor-arg name="age" value="14"></constructor-arg>
</bean>

复杂对象

<?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-3.0.xsd">
    <bean id="guanyu" class="com.neuedu.test.GuanYu">
        <constructor-arg name="name" value="关羽"></constructor-arg>
        <!--属性注入如果是对象，需要用ref关联另一个对象id-->
        <constructor-arg name="weapon" ref="qinglong"></constructor-arg>
    </bean>
    <!--配一个QingLong-->
    <bean id="qinglong" class="com.neuedu.test.QingLong">
        <property name="dps" value="50"></property>
    </bean>
</beans>

集合

setter注入

<bean id="guanyu" class="com.neuedu.test.GuanYu">
    <!--利用set方法注入属性-->
    <property name="name" value="关羽坤"></property>
    <property name="age" value="144"></property>
</bean>

复杂对象

<?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-3.0.xsd">
    <bean id="guanyu" class="com.neuedu.test.GuanYu">
        <property name="name" value="关羽"></property>
        <!--属性注入如果是对象，需要用ref关联另一个对象id-->
        <property name="weapon" ref="qinglong"></property>
    </bean>
    <!--配一个QingLong-->
    <bean id="qinglong" class="com.neuedu.test.QingLong">
        <property name="dps" value="50"></property>
    </bean>
</beans>

集合

<bean id="guanyu" class="com.neuedu.test.GuanYu">
        <property name="name" value="关羽"></property>
        <!--属性注入如果是对象，需要用ref关联另一个对象id-->
        <property name="weapon" ref="qinglong"></property>
        <!--List<String>-->
        <property name="boy">
            <list>
                <value>张飞</value>
                <value>马超</value>
            </list>
        </property>
        <!--List<Weapon>-->
        <property name="repository">
            <list>
                <ref bean="qinglong"></ref>
                <ref bean="fang"></ref>
            </list>
        </property>
        <!--Map<String,String>-->
        <property name="horse">
            <map>
                <entry key="坐骑1" value="赤兔"></entry>
                <entry key="坐骑2" value="的卢"></entry>
            </map>
        </property>
        <!--Map<String,Weapon>-->
        <property name="weaponMap">
            <map>
                <entry key="武器1" value-ref="qinglong"></entry>
                <entry key="武器2" value-ref="fang"></entry>
            </map>
        </property>
    </bean>

接口注入（Spring不支持）

自动装配（了解）

<!-- ==========================自动按名字装配autowire=byName=========================== -->
<!-- ==========================自动按类型装配autowire=byType=========================== -->
<bean id="qiyi" class="com.neuedu.test1.QiYi" autowire="byType"/>
<!-- 当按照类型装配时，有多个符合条件的对象，需要指定primary="true"表明是主要的装配对象 -->
<bean id="wuqi" class="com.neuedu.test1.FaZhang" primary="true">
    <property name="name" value="大法师之杖"></property>
</bean>
<bean id="kandao" class="com.neuedu.test1.KanDao">
    <property name="name" value="大法师砍刀"></property>
</bean>

====================

<?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-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <!-- 开启注解 -->
    <context:annotation-config />
    <bean id="guanyu" class="com.neuedu.test.GuanYu"></bean>
    <bean id="abc1" class="com.neuedu.test.QingLong">
        <qualifier value="test1"></qualifier>
    </bean>
    <bean id="abc2" class="com.neuedu.test.Fang">
        <qualifier value="test2"></qualifier>
    </bean>
</beans>

package com.neuedu.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class GuanYu implements Fighter {
    private String name = "关羽";
    @Autowired
    @Qualifier("test2")// 转配的com.neuedu.test.Fang
    private Weapon weapon;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
    public void show() {
        System.out.println(name);
        weapon.showInfo();
    }
}

注解自动装配（重要）

spring.xml配置扫描包

<?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-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!----->
    <context:component-scan base-package="com.neuedu.test"></context:component-scan>
    <bean id="guanyu" class="com.neuedu.test.GuanYu"></bean>
</beans>

2019-05-23Spring入门

IOC控制反转/DI依赖注入

spring配置文件

IOC控制反转

DI依赖注入

IOC控制反转和DI依赖注入没有区别，只是针对参照物不同的不同说法

属性注入

复杂对象

集合

复杂对象

集合

自动装配（了解）

注解自动装配（重要）

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读