JavaEE Spring IoC入门-阿里云开发者社区

1. Spring 官网

发开包下载

图1.png

下载并解压：

图2.png

其中：

docs：API和开发规范
libs：Jar包和源码
schema：约束

2. 创建Web工程

导入Jar包：spring-beans-5.0.5.RELEASE.jar、spring-context-5.0.5.RELEASE.jar、spring-core-5.0.5.RELEASE.jar、spring-expression-5.0.5.RELEASE.jar、commons-logging-1.2.jar.

图3.png

3. 测试

1). 创建User类

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

2). 在src下创建bean.xml文件，用于配置User类

<?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">

    <!-- 1.配置User对象的创建 -->
    <bean id="user" class="com.mazaiting.ioc.User"></bean>
</beans>

图4.png

3). 编写测试程序

public class TestUser {
    @Test
    public void test() {
        // 1. 加载Spring配置文件, classpath：类路径，src目录下的文件最终要编译到类路径下
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据配置文件的id得到user对象
        User user = (User) context.getBean("user");
        user.add();     
    }
}

打印结果：

图5.png

4. Spring实例化bean的三种方式

1). 无参构造

<!-- 1.配置user对象的创建 --> 
<bean id="user" class="cn.itcast.ioc.User"></bean>

2). 静态工厂
I. 创建一个类

public class Bean1 {
    public void bean1() {
        System.out.println("bean1.....");
    }
}

II. 创建一个工厂类

public class Bean1Factory {
    // 静态方法
    public static Bean1 getBean1() {
        return new Bean1();
    }
}

III. 配置文件配置

<?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="bean1" class="com.mazaiting.ioc.staticfactory.Bean1Factory"
        factory-method="getBean1"></bean>
</beans>

IV. 创建测试类

public class TestBean1 {
    @Test
    public void test() {
        // 1. 加载Spring配置文件，指配置文件中的对象进行创建
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据配置文件id得到bean对象
        Bean1 bean1 = (Bean1) context.getBean("bean1");
        bean1.bean1();
    }
}

V. 打印结果：

图6.png

3). 实例工厂
I. 创建Bean2类

public class Bean2 {

    public void bean2() {
        System.out.println("bean2....");
    }
}

II. 创建工厂

public class Bean2Factory {

    public Bean2 getBean2() {
        return new Bean2();
    }
}

III. 设置配置文件

<?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">
    <!-- 3.使用实例工厂创建对象 -->
    <!-- 3.1 先创建工厂对象 -->
    <bean id="bean2Factory" class="com.mazaiting.ioc.instancefactory.Bean2Factory"></bean>
    <!-- 3.2 再使用工厂对象创建bean2对象 -->
    <bean id="bean2" factory-bean="bean2Factory" factory-method="getBean2"></bean>
</beans>

IV. 创建测试类

public class TestBean2 {
    
    @Test
    public void test() {
        // 1. 加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据配置文件的id得到bean2对象
        Bean2 bean2 = (Bean2) context.getBean("bean2");
        bean2.bean2();
    }
}

V. 打印结果：

图7.png

5. Spring配置文件中bean标签常用的属性

1). id属性：根据id属性值得到配置对象。
在Spring配置文件中会有多个bean标签，但它们的id属性值是不能相同的。Bean起名字时，在约束中采用的是ID约束——唯一，而且名字必须以字母开始，可以使用字母、数字、连字符、下划线、句号、冒号等，但id属性值不能有特殊符号。
2). class属性：要创建对象的类的全路径。
3). scope属性：bean的作用范围

singleton：创建的对象是单例的，也是scope属性的默认值。
prototype：创建的对象是多实例的。
globalSession：用在单点登录(即SSO，single sign on)上。

4). name属性：name属性的功能和id属性是一样的。name属性和id属性区别是：在id属性值里面不能有特殊符号，在name属性值里面可以添加特殊符号。
5). factory-bean属性：工厂类所配置的bean节点中的id值。
6). factory-method属性：工厂类中获取当前节点对象的方法名。
7). lazy-init属性：true表示延迟初始化bean；false表示在加载bean.xml文件时就创建对象
8). init-method属性：指定初始化的方法名：init
9). destroy-method属性：指定销毁对象的方法名：destroy

6. Spring中Bean的属性注入

1). 构造参数注入
I. 创建Book类

public class Book {
    private String name;
    
    public Book(String name) {
        this.name = name;
    }
    
    public void testBook() {
        System.out.println("Book---------------" + this.name);
    }
}

II. 设置配置文件

<?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">
    <!-- 4.使用有参数的构造注入属性 -->
    <bean id="book" class="com.mazaiting.property.cont.Book" >
        <!-- 使用标签，name：为属性的名字，value，为属性的值 -->
        <constructor-arg name="name" value="beautifulman_美美侠"></constructor-arg>
    </bean>
</beans>

III. 创建测试类

public class TestBook {
    @Test
    public void test() {
        // 1. 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 获取对象
        Book book = (Book) context.getBean("book");
        book.testBook();
    }
}

IV. 测试结果：

图8.png

2). set方法注入
I. 创建Person类

public class Person {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void testPerson() {
        System.out.println("Person--------------" + name);
    }
}

II. 设置配置文件

<?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">
    <!-- 5.使用set方法进行注入属性 -->
    <bean id="person" class="com.mazaiting.property.pro.Person">
        <!-- 使用property标签注入属性值
        name：类属性名称
        value属性：往属性中注入的值 -->
        <property name="name" value="mazaiting"></property>
    </bean>
</beans>

III. 创建测试类

public class TestPerson {
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 根据配置文件的id得到Person对象
        Person person = (Person) context.getBean("person");
        person.testPerson();
    }
}

IV. 打印结果：

图9.png

3). 接口注入--不支持

7. 对象注入

1). 对象注入
I. 创建UserDao类

public class UserDao {
    public void add() {
        System.out.println("dao..........");
    }
}

II. 创建Service类，并使用set方法注入

public class UserService {
    // 1. 让dao作为service的一个属性
    private UserDao userDao;
    
    // 2. 生成dao属性的set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }   
    
    public void add() {
        System.out.println("service..........");
        userDao.add();
    }
}

III. 添加配置

<?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">

    <!-- 6. 注入对象的属性 -->
    <!-- 6.1 先创建dao对象 -->
    <bean id="userDao" class="com.mazaiting.property.obj.UserDao"></bean>
    <!-- 6.2 再创建service对象 -->
    <bean id="userService" class="com.mazaiting.property.obj.UserService">
        <!-- 在servcie里面注入userDao属性
            name属性：service对象里面的userDao属性的名称
            注入dao对象，不能写value属性，要写ref属性：dao配置的bean的id值 
        -->
        <property name="userDao" ref="userDao"></property>
        
    </bean>
    
</beans>

IV. 创建测试类

public class TestUser {
    
    @Test
    public void test() {
        // 1. 加载bean.xml配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 获取对象
        UserService service = (UserService) context.getBean("userService");
        service.add();
    }
}

V. 运行结果

图10.png

8. 名称空间p的属性注入

I. 创建Orders类

public class Orders {
    private String oname;
    
    public void setOname(String oname) {
        this.oname = oname;
    }
    
    public void testOrders() {
        System.out.println("orders..............." + oname);
    }
}

II. 在Spring核心配置文件中的schema约束位置定义p名称空间

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

图11.png

III. 添加配置

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 7. p(property，属性)名称空间的注入 -->
    <bean id="orders" class="com.mazaiting.property.namespace.Orders" p:oname="mazaiting"></bean>
    
</beans>

IV. 编写测试类

public class TestOrders {
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 获取Orders对象
        Orders orders = (Orders) context.getBean("orders");
        orders.testOrders();
    }
}

V. 执行结果

图12.png

9. 注入数组类型的属性

I. 编写DataArr类

public class DataArr {
    private String[] arrays;
    public void setArrays(String[] arrays) {
        this.arrays = arrays;
    }
    public void testArr(){
        System.out.println("数组：" + Arrays.toString(arrays));
    }
}

II. 添加配置

<?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="dataArr" class="com.mazaiting.property.arr.DataArr">
        <!-- 注入属性 -->
        <property name="arrays">
            <list>
                <value>香蕉</value>
                <value>苹果</value>
                <value>橘子</value>
            </list>
        </property>
    </bean>
</beans>

III. 创建测试类

public class TestDataArr {
    
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 获取对象
        DataArr dataArr = (DataArr) context.getBean("dataArr");
        dataArr.testArr();
    }
}

IV. 打印结果

图13.png

10. 注入List集合类型的属性

I. 创建DataList类

public class DataList {
    private List<String> list;
    public void setList(List<String> list) {
        this.list = list;
    }
    public void test() {
        System.out.println("list......." + list.toString());
    }
}

II. 添加配置

<?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="dataList" class="com.mazaiting.property.list.DataList">
        <property name="list">
            <list>
                <value>香蕉</value>
                <value>苹果</value>
                <value>橘子</value>
            </list>
        </property>
    </bean>
    
</beans>

III. 创建测试类

public class TestList {
    
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 创建对象
        DataList list = (DataList) context.getBean("dataList");
        list.test();
    }
}

IV. 打印结果

图14.png

11. 注入Set集合类型的属性

I. 创建DataSet类

public class DataSet {
    private Set<String> set;
    public void setSet(Set<String> set) {
        this.set = set;
    }
    public void test() {
        System.out.println("set: " + set.toString());
    }
}

II. 添加配置

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="dataSet" class="com.mazaiting.property.set.DataSet">
        <property name="set">
            <set>
                <value>香蕉</value>
                <value>苹果</value>
                <value>橘子</value>
            </set>
        </property>
    </bean>
</beans>

III. 创建测试类

public class TestSet {
    
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 创建对象
        DataSet set = (DataSet) context.getBean("dataSet");
        set.test();
    }
}

IV. 打印结果

图14.png

12. 注入Map集合类型的属性

I. 创建DataMap类

public class DataMap {
    private Map<String, String> map;
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    public void test() {
        System.out.println("map........." + map.toString());
    }
}

II. 加载配置

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="dataMap" class="com.mazaiting.property.map.DataMap">
        <property name="map">
            <map>
                <entry key="username" value="麻再挺"/>
                <entry key="password" value="1314"/>
                <entry key="address" value="科学院"/>
            </map>
        </property>
    </bean>
</beans>

III. 创建测试类

public class TestMap {
    
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 创建对象
        DataMap map = (DataMap) context.getBean("dataMap");
        map.test();
    }
}

IV. 打印结果

图15.png

13. 注入Properties类型的属性

I. 创建DataProperty类

public class DataProperty {
    private Properties properties;
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    public void test() {
        System.out.println("properties: " + properties);
    }
}

II. 添加配置

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="dataProperty" class="com.mazaiting.property.proper.DataProperty">
        <property name="properties">
            <props>
                <prop key="name">麻再挺</prop>
                <prop key="age">24</prop>
            </props>
        </property>
    </bean>
</beans>

III. 创建测试文件

public class TestProperty {
    
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 创建对象
        DataProperty property = (DataProperty) context.getBean("dataProperty");
        property.test();
    }
}

IV. 打印结果

图16.png

14. IoC和DI

IOC：Inversion of Control，控制反转。指的是对象的创建权反转(交给)给Spring，其作用是实现了程序的解耦合
DI(Dependency Injection)：依赖注入，即在创建对象的过程中，向类里面的属性中设置值。

15. ApplicationContext实现类

ClassPathXmlApplicationContext：加载的是类路径下的Spring配置文件
FileSystemXmlApplicationContext：加载的是本地磁盘下的Spring配置文件

JavaEE Spring IoC入门

1. Spring 官网

2. 创建Web工程

3. 测试

4. Spring实例化bean的三种方式

5. Spring配置文件中bean标签常用的属性

6. Spring中Bean的属性注入

7. 对象注入

8. 名称空间p的属性注入

9. 注入数组类型的属性

10. 注入List集合类型的属性

11. 注入Set集合类型的属性

12. 注入Map集合类型的属性

13. 注入Properties类型的属性

14. IoC和DI

15. ApplicationContext实现类

代码下载

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

JavaEE Spring IoC入门

1. Spring 官网

2. 创建Web工程

3. 测试

4. Spring实例化bean的三种方式

5. Spring配置文件中bean标签常用的属性

6. Spring中Bean的属性注入

7. 对象注入

8. 名称空间p的属性注入

9. 注入数组类型的属性

10. 注入List集合类型的属性

11. 注入Set集合类型的属性

12. 注入Map集合类型的属性

13. 注入Properties类型的属性

14. IoC和DI

15. ApplicationContext实现类

热门文章

最新文章

相关课程

相关电子书

相关实验场景