Spring基础-01

1.Spring第一个程序

pom依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.8</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.1</version>
    <scope>test</scope>
</dependency>

spring配置文件

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userDao" class="com.my.dao.UserDao"/>
</beans>

java程序

package com.my.dao;

public class UserDao {

    public void getUser() {
        System.out.println("get user");
    }
}

public class UserTest {

    @Test
    public void test01() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserDao userDao = (UserDao) context.getBean("userDao");
        UserDao.getUser();
    }
}

2.set方法注入

UserService需要注入name和UserDao。

public class UserService {

    private String name;

    private UserDao userDao;

    public void setName(String name) {
        System.out.println("set name");
        this.name = name;
    }

    public void getUser() {
        System.out.println(name);
        userDao.getUser();
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public String toString() {
        return "UserService{" +
                "name='" + name + '\'' +
                '}';
    }
}

set方式注入

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userDao" class="com.my.dao.UserDao"/>

    <bean id="userService" class="com.my.service.UserService">
        <!-- value 注入值类型；ref 注入引用类型 -->
        <!-- 通过property注入的值或者引用，必须为其提供 set接口，否则报错无法注入 -->
        <!-- property 是通过set方法赋值 -->
        <property name="name" value="tom"/>
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

通过property注入的值或者引用，必须为其提供set接口，否则报错无法注入。
value注入值类型；ref注入引用类型。

3.通过构造器注入的三种方式

实体类。通过构造方法为User注入id和name。

public class User {

    private Integer id;
    private String name;

    public User() {}

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

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

通过构造方法的索引赋值。

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 通过构造器创建对象 通过构造器参数的索引赋值。 -->
    <bean id="user" class="com.my.pojo.User">
        <constructor-arg index="0" value="1"/>
        <constructor-arg index="1" value="tom"/>
    </bean>
</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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 通过构造器参数的类型赋值，只适合于类型唯一的情况 -->
    <bean id="user" class="com.my.pojo.User">
        <constructor-arg type="java.lang.Integer" value="12"/>
        <constructor-arg type="java.lang.String" value="tom"/>
    </bean>
</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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 通过构造器参数命赋值 -->
    <bean id="user" class="com.my.pojo.User">
        <constructor-arg name="id" value="123"/>
        <constructor-arg name="name" value="tom"/>
    </bean> name="id" value="10"/>
</beans>

4.spring配置文件

bean的别名。通过alias标签取别名，或者bean标签的name属性定义别名。

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="user" class="com.my.pojo.User">
        <constructor-arg index="0" value="1"/>
        <constructor-arg index="1" value="tom"/>
    </bean>

    <!-- 给bean取别名。 -->
    <alias name="user" alias="newUser"/>

    <!-- name 可以取多个别名 -->
    <bean id="user" class="com.my.pojo.User" name="u1 u2">
        <property name="id" value="10"/>
    </bean>
</beans>

import将多个spring配置文件合为一个。applicationContext.xml中合入beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 导入其他的Spring配置文件 -->
    <import resource="beans.xml"/>
</beans>

5.依赖注入

set方法注入，同2。
构造器注入，同3。
参数注入list、set、map、数组、null、properties。

public class Student {

    private String id;
    private Class aClass;
    private String[] n;
    private List<String> list;
    private Map<Integer, String> map;
    private Set<Integer> set;
    private String nullValue;
    private Properties properties;

    public String getId() {
        return id;
    }

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

    public Class getaClass() {
        return aClass;
    }

    public void setaClass(Class aClass) {
        this.aClass = aClass;
    }

    public String[] getN() {
        return n;
    }

    public void setN(String[] n) {
        this.n = n;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Map<Integer, String> getMap() {
        return map;
    }

    public void setMap(Map<Integer, String> map) {
        this.map = map;
    }

    public Set<Integer> getSet() {
        return set;
    }

    public void setSet(Set<Integer> set) {
        this.set = set;
    }

    public String getNullValue() {
        return nullValue;
    }

    public void setNullValue(String nullValue) {
        this.nullValue = nullValue;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", aClass=" + aClass +
                ", n=" + Arrays.toString(n) +
                ", list=" + list +
                ", map=" + map +
                ", set=" + set +
                ", nullValue='" + nullValue + '\'' +
                ", properties=" + properties +
                '}';
    }
}

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="student" class="com.my.pojo.Student">
        <property name="id" value="tom01"/>
        <property name="aClass" ref="aclass"/>
        <!-- 数组 -->
        <property name="n">
            <array>
                <value>t01</value>
                <value>t02</value>
            </array>
        </property>

        <property name="list">
            <list>
                <value>l1</value>
                <value>l2</value>
                <value>l3</value>
            </list>
        </property>

        <property name="map">
            <map>
                <entry key="1" value="m1"/>
                <entry key="2" value="m2"/>
                <entry key="3" value="m3"/>
            </map>
        </property>

        <property name="set">
            <set>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </set>
        </property>

        <!-- null注入，使用value=""，注入的是非null的空字符串 -->
        <property name="nullValue">
            <null/>
        </property>

        <property name="properties">
            <props>
                <prop key="1">p1</prop>
                <prop key="2">p2</prop>
                <prop key="3">p3</prop>
            </props>
        </property>
    </bean>
</beans>

其他注入方式。p、c注入。p相当与set方法注入，c相当与构造器注入。

<?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"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- p: 注入，相当与set注入，所以需要有set方法 -->
    <bean id="person" class="com.my.pojo.Person" p:id="23" p:name="tom"/>

    <!-- c: 注入，相当与构造器注入，需要有相关的构造器 -->
    <bean id="p" class="com.my.pojo.Person" c:id="30" c:name="bob" c:age="30"/>
</beans>

6.bean的作用域

singleton，单例。全局只有一个对象，是spring的默认配置，适合于单线程环境。
prototype，原型。多个bean的对象。
request，每一个HTTP请求都会产生一个Bean对象，只在基于web的Spring ApplicationContext中可以使用。
session，bean的作用域为一次会话的生命周期，只有基于web的Spring ApplicationContext才能使用。
websocket，待完善。

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- scope="singleton"，单列模式，全局只有一个对象，默认的选择，适合于单线程 -->
    <bean id="p1" class="com.my.pojo.Person" scope="singleton"/>

    <bean id="p2" class="com.my.pojo.Person" scope="prototype"/>
</beans>

7.bean的自动装配-xml

Java实体类。需要将Class装配到Person中。

public class Person {
    private Class aClass;

    public Class getaClass() {
        return aClass;
    }

    public void setaClass(Class aClass) {
        this.aClass = aClass;
    }
}

public class Class {

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

byName自动装配。

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="aClass" class="com.my.pojo.Class"/>

    <!-- byName 自动装配，通过set方法的后半部分进行自动装配，
    所以需要保证，bean的id和set方法一致 -->
    <bean id="p" class="com.my.pojo.Person" autowire="byName"/>

    <!-- 通过bean的类型进行装配，需要保证这个类型的Bean(Class)Spring容器中只有一个实例，
     同时autowire="byType"通过set方法注入引用，所以需要提供set方法-->
    <bean id="p1" class="com.my.pojo.Person" autowire="byType"/>
</beans>

byType自动装配。

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="aClass" class="com.my.pojo.Class"/>

    <!-- 通过bean的类型进行装配，需要保证这个类型的Bean(Class)Spring容器中只有一个实例，
     同时autowire="byType"通过set方法注入引用，所以需要提供set方法-->
    <bean id="p1" class="com.my.pojo.Person" autowire="byType"/>
</beans>

8.bean自动装配-注解

Java实体类，Person中注入Car。

public interface ICar {

    void print();
}

public class Car implements ICar{

    @Override
    public void print() {
        System.out.println("print car");
    }
}

public class Person {

    /**
     *  1、
     *  2、@Autowired，容器中必须存在Car的实例对象，而且只有一个。否则报错。
     *  3、@Autowired(required = false)，容器中可以没有Car实例对象。
     *  4、如果容器中有多个实例，会按照属性名(car)进行匹配，没有匹配到当前属性名(car)报错。
     *  5、@Qualifier(value = "car1")，通过value和容器中的Car实例名进行匹配。
     *
     *  6 @Autowired 先通过类型匹配，如果一个类型有多个实例，在通过name进行匹配，
     *  如果name都不一致报错。可以通过@Qualifier("car")制定name进行匹配。
     *  7 @Resource=@Autowired+@Qualfier，先通过name查找，name不匹配在通过类型查找。
     *  如果@Resource(name = "car1")配置了name，
     *  直接通过name进行查找，没有找到 即使只有一个实例也会报错。
     */
    //@Autowired
    //@Qualifier("car")
    @Resource(name = "car1")
    private Car car;

    public ICar getCar() {
        return car;
    }
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 开启注解配置 -->
    <context:annotation-config/>

    <bean id="car1" class="com.my.domain.Car"/>
    <bean id="p" class="com.my.domain.Person"/>
</beans>

@Autowired注解。
1. @Autowired，通过类型进行装配，通过反射注入Car引用，所以不需要set方法。
2. 使用@Autowired，容器中必须存在Car的实例对象，否则报错。
3. 如果@Autowired(required = false)，容器中可以没有Car实例对象。
4. 如果容器中有多个实例，会按照属性名(car)进行匹配，没有匹配到当前属性名(car)报错。
5. @Autowired先通过类型匹配，容器中只有一个同类型的对象，直接匹配成功。如果一个类型有多个实例，在通过属性名进行匹配。如果属性名都不一致报错。
@Qualifier注解。
1. @Qualifier(value = "car1")，通过value和容器中的Car实例名进行匹配。
2. @Qualifier可以和@Autowired一起使用，先通过类型进行匹配，如果容器中有多个同类型的对象，在通过@Qualifier的value进行匹配。
@Resource注解。
1. @Resource，相当与@Autowired+@Qualfier，先通过属性名查找，属性名不匹配在通过类型查找。
2. 如果@Resource(name = "car1")配置了name，直接通过name进行查找，没有找到。即使容器中只有一个实例也会报错。

posted @ 2021-07-31 21:21 行稳致远方阅读(48) 评论(0) 收藏举报

刷新页面返回顶部

行稳致远方

Spring基础-01

Spring基础-01

1.Spring第一个程序

2.set方法注入

3.通过构造器注入的三种方式

4.spring配置文件

5.依赖注入

6.bean的作用域

7.bean的自动装配-xml

8.bean自动装配-注解

公告