Spring从入门到入土(xml配置文件的基础使用方式)

1. xml配置文件的读取

目录结构

applicationContext.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-4.3.xsd">

    <!--通过无参构造创建对象-->
    <bean id = "userDao" class="org.example.POI.UserDaoImpl"/>

</beans>

1.1 通过类路径读取配置文件

package org.example.POI;

public interface UserDao {
    public void say();
}

package org.example.POI;

public class UserDaoImpl implements UserDao{
    @Override
    public void say() {
        System.out.println("userDao say Hello World!");
    }
}

    @Test
    public void shouldAnswerWithTrue()
    {
        //读取配置文件,创建Spring容器, 根据类路径读取
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据id获取对象
        UserDao userDao = (UserDao) context.getBean("userDao");
        UserDao userDao2 = (UserDao) context.getBean("userDao");
        //使用对象调用方法
        userDao.say();
        //默认单例
        System.out.println(userDao == userDao2);

    }

1.2 通过文件系统绝对路径读取配置文件

    @Test
    public void Test01(){
        //根据文件系统的绝对路径读取配置文件
        ApplicationContext context1 =
                new FileSystemXmlApplicationContext("E:\\绝对路径 "+          
        "\\src\\main\\resource\\applicationContext.xml");
        UserDao userDao1 = (UserDao) context1.getBean("userDao");
        UserDao userDao2 = (UserDao) context1.getBean("userDao");

        userDao1.say();
        //默认单例
        System.out.println(userDao1 == userDao2);
    }

1.3 使用BeanFactory接口读取配置文件

    @Test
    public void diffrentTest(){
        //将配置文件信息封装到Resource对象中
        ClassPathResource resource = new ClassPathResource("applicationContext.xml");
        //通过Resource对象创建容器
        BeanFactory beanFactory = new XmlBeanFactory(resource);
        //通过id获取对应的对象
        UserDao userDao = (UserDao) beanFactory.getBean("userDao");
        UserDao userDao1 = (UserDao) beanFactory.getBean("userDao");
        userDao.say();
        System.out.println(userDao == userDao1);
    }

BeanFactory 创建对象时才调用构造函数创建对象 延迟加载

ApplicationContext 在创建容器时就调用构造创建对象(读取配置文件后马上创建对象) 立即加载

2. 带参构造对象的创建(constructor-arg标签)

public class User {
    private Integer age;
    private String userName;

    public User() {
    }

    public User(Integer age, String userName) {
        this.age = age;
        this.userName = userName;
    }

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

<!-- 调用有参构造,反射创建对象-->
<bean id = "user" class="org.example.pojo.User">
    <constructor-arg name="age" value="18"></constructor-arg>
    <constructor-arg name="userName" value="貂蝉"></constructor-arg>
</bean>

    //创建带参构造对象
    @Test
    public void haveArgStruct(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User) context.getBean("user");
        System.out.println(user);
    }

3. 使用另一个类中的方法创建对象, 并放到Spring容器中

package org.example.POI;

public interface UserService {
    public void say();
}

public class UserServiceImpl implements UserService{
    private UserDao userDao;
    public  void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }

    public UserDao createUserDao(){
        System.out.println("我是UserServiceImpl,我创建了UserDao----");
        UserDao userDao = new UserDaoImpl();
        return userDao;
    }

    @Override
    public void say() {
        this.userDao.say();
        System.out.println("userService say hello World!");
    }
}

 <!--调用另一个类中的方法创建对象并将其加入到Spring容器中-->
    <bean id="userDaoService" class="org.example.POI.UserServiceImpl"></bean>
    <!--factory-bean: 另一个类的id  factory-method: 另一个类中创建指定对象的方法名-->
    <bean id="userDaoByService" factory-bean="userDaoService" factory-method="createUserDao"></bean>

    //调用另一个类中的方法创建对象
    @Test
    public void userDaoByUserService(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) context.getBean("userDaoByService");
        userDao.say();
    }

4. 调用另一个类中的静态方法创建对象, 并放到Spring容器中

public class UserServiceImpl implements UserService{
    private UserDao userDao;
    public  void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }

    public static UserDao createUserDao1(){
        System.out.println("我是static createUserDao1,我创建了UserDao----");
        return new UserDaoImpl();
    }

    @Override
    public void say() {
        this.userDao.say();
        System.out.println("userService say hello World!");
    }
}

  <!--调用类中的静态方法创建对象存放到Spring容器中-->
    <bean id="userDaoByService1" class="org.example.POI.UserServiceImpl" factory-method="createUserDao1"></bean>

    //调用另一个类中的静态方法创建对象
    @Test
    public void userDaoByUserService1(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) context.getBean("userDaoByService1");
        userDao.say();
    }

5. 对象的生命周期

package org.example.POI;

public class UserDaoImpl implements UserDao{
    public UserDaoImpl(){
        System.out.println("UserDaoImpl无参构造调用--------");
    }
    @Override
    public void say() {
        System.out.println("userDao say Hello World!");
    }
    public void demo01(){
        System.out.println("init obj!");
    }
    public void demo02(){
        System.out.println("destroy obj!");
    }
}

    //对象的生命周期
    @Test
    public void lifecycle(){
        //创建容器
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //销毁容器
        ((ClassPathXmlApplicationContext)context).close();
    }

  <!--对象的生命周期-->
  <!--init-method: 创建容器时调用demo01函数-->
  <!--destroy-method: 销毁容器时调用demo02函数-->
    <bean id="lifecycle" init-method="demo01" destroy-method="demo02" class="org.example.POI.UserDaoImpl"></bean>

6. 单例多例的测试

package org.example.POI;

public class UserDaoImpl implements UserDao{
    public UserDaoImpl(){
        System.out.println("UserDaoImpl无参构造调用--------");
    }
    @Override
    public void say() {
        System.out.println("userDao say Hello World!");
    }
}

    @Test
    public void shouldAnswerWithTrue()
    {
        //读取配置文件,读取Spring容器, 根据类路径读取
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据id获取对象
        UserDao userDao = (UserDao) context.getBean("userDao");
        UserDao userDao2 = (UserDao) context.getBean("userDao");
        //使用对象调用方法
        userDao.say();
        //默认单例
        System.out.println(userDao == userDao2);
    }

多例

  <bean id = "userDao" scope="prototype" class="org.example.POI.UserDaoImpl"/>

默认单例

<bean id = "userDao" scope="singleton" class="org.example.POI.UserDaoImpl"/>