victory的博客

长安一片月,万户捣衣声

0%

基于注解(@Autowired)的自动装配

1.项目目录

2.UserController.java

package com.atguigu.ioc.userMod.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import com.atguigu.ioc.userMod.service.UserService;
import com.atguigu.ioc.userMod.service.UserServiceImpl;

/**
 * 基于注解的组件化管理:
 * @Component,@Controller(控制层),@Service(业务层),@Repository(持久曾)
 * 以上四个注解功能完全相同,不过在实际开发中,要在实现不同功能的类上加上相应的注解
 * 完成组件化管理的过程:
 * 1、在需要被spring管理的类上加上相应注解
 * 2、在配置文件中通过<context:component-scan>对所设置的包结构进行扫描,就会将加上注解的类作为spring的组件进行加载
 * 组件:指spring中管理的bean
 * 作为spring的组件进行加载:会自动在spring的配置文件中生成相对应的bean,这些bean的id会以类的首字母小写为值;
 * 也可以通过@Controller("beanId")为自动生成的bean指定id
 * 
 * 自动装配:在需要赋值的非字面量属性上,加上@Autowired注解,就可以在spring容器中,通过不同的方式匹配到相对应的bean
 * @Autowired装配时,会默认使用byType的方式,此时要求spring容器中只有一个能够为其赋值
 * 当byType实现不了装配时,会自动切换到byName,此时要求spring容器中,有一个bean的id和属性名一致
 * 若自动装配时,匹配到多个能够赋值的bean,可使用@Qualifire(value="beanId")指定使用的bean
 * @Autowired和@Qualifire(value="beanId")可以一起作用于一个带形参的方法上,此时,@Qualifire(value="beanId")所
 * 指定的bean作用于形参
 * 
 */

@Controller
//@Controller(value="aaa")//为自动创建的bean设置id
public class UserController {
    //private UserService userService = new UserServiceImpl();
    @Autowired//基于注解的自动装配(根据类型进行自动装配 byType)
    private UserService userService;
    
    public void addUser(){
        userService.addUser();
    }
    
    public UserController() {
        System.out.println("UserController");
    }
}

3.UserService.java

package com.atguigu.ioc.userMod.service;

public interface UserService {
    void addUser();
}

4.UserServiceImpl.java

package com.atguigu.ioc.userMod.service;

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

import com.atguigu.ioc.userMod.dao.UserDao;
import com.atguigu.ioc.userMod.dao.UserDaoImpl;

@Service
public class UserServiceImpl implements UserService{
    
    //private UserDao userDao = new UserDaoImpl();
    
    @Autowired
    //@Qualifier(value="userDaoImpl")
    @Qualifier(value="userDaoMybatisImpl")
    private UserDao userDao;
    
//    @Autowired
//    @Qualifier(value="userDaoMybaticImpl")
//    public void setUserDao(UserDao userDao){
//        this.userDao = userDao;
//    }
    
    public UserServiceImpl() {
        System.out.println("UserServiceImpl");
    }

    @Override
    public void addUser() {
        // TODO Auto-generated method stub
        userDao.addUser();
    }

}

5.UserDao.java

package com.atguigu.ioc.userMod.dao;

public interface UserDao {
    void addUser();
}

6.UserDaoImpl.java

package com.atguigu.ioc.userMod.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao{
    public UserDaoImpl(){
        System.out.println("UserDaoImpl");
    }

    @Override
    public void addUser() {
        System.out.println("添加成功");
    }
}

7.UserDaoMybatisImpl.java

package com.atguigu.ioc.userMod.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoMybatisImpl implements UserDao{

    @Override
    public void addUser() {
        // TODO Auto-generated method stub
        System.out.println("UserDaoMybatisImple:添加成功");
    }
}

8.user.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.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <!-- 
        <context:component-scan>:扫描组件,对设置的包下面的类进行扫描,会将加上注解的类作为spring的组件进行加载
        组件:指spring中管理的bean
        作为spring的组件进行加载:会自动在spring的配置文件中生成相对应的bean,这些bean的id会以类的首字母小写为值
        
        <context:include-filter>:在设定的包结构下再次通过注解或类型具体包含到某个或某几个类
        注意:在使用包含时,一定要设置use-default-filters="false",将默认(即扫描包下所有的类)的过滤关闭
        
        <context:exclude-filter>:在设定的包结构下,再次通过注解或类型具体排除某个或某几个类
        注意:在使用排除时,一定要设置use-default-filters="true",将默认(即扫描包下所有的类)的过滤打开
        
        切记:一个<context:component-scan>中可以出现多个include,也可以同时出现多个exclude,但是两个不能同时出现
     -->
    <context:component-scan base-package="com.atguigu.ioc.userMod" use-default-filters="true">
        <!-- <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> -->
        <!-- <context:include-filter type="assignable" expression="com.atguigu.ioc.userMod.service.UserServiceImpl"/> -->
        <!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/> -->
        <!-- <context:exclude-filter type="assignable" expression="com.atguigu.ioc.userMod.dao.UserDaoImpl"/> -->
    </context:component-scan>
    
    <!-- <bean id="userController" class="com.atguigu.ioc.userMod.controller.UserController"></bean>
    <bean id="userServiceImpl" class="com.atguigu.ioc.userMod.service.UserServiceImpl"></bean>
    <bean id="userDaoImpl" class="com.atguigu.ioc.userMod.dao.UserDaoImpl"></bean> -->
    
    <!-- 测试@Autowired是根据类型来进行自动装配的(byType) -->
    <!-- <bean id="user" class="com.atguigu.ioc.userMod.dao.UserDaoImpl"></bean> -->
    
    <!-- 如果根据类型自动装配失败,则byName -->
    <!-- <bean id="userDao" class="com.atguigu.ioc.userMod.dao.UserDaoImpl"></bean> -->
</beans>

9.Test.java

package com.atguigu.ioc.userMod;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.atguigu.ioc.userMod.controller.UserController;
import com.atguigu.ioc.userMod.dao.UserDao;
import com.atguigu.ioc.userMod.dao.UserDaoImpl;
import com.atguigu.ioc.userMod.service.UserService;
import com.atguigu.ioc.userMod.service.UserServiceImpl;

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("user.xml");
        
        UserController uc = ac.getBean("userController", UserController.class);
        System.out.println(uc);//com.atguigu.ioc.userMod.controller.UserController@4b553d26
        
        UserService us = ac.getBean("userServiceImpl", UserServiceImpl.class);
        System.out.println(us);//com.atguigu.ioc.userMod.service.UserServiceImpl@69a3d1d
        
        UserDao ud = ac.getBean("userDaoImpl", UserDaoImpl.class);
        System.out.println(ud);//com.atguigu.ioc.userMod.dao.UserDaoImpl@86be70a
        
        uc.addUser();
    }
}

10.运行结果

UserController
UserServiceImpl
UserDaoImpl
com.atguigu.ioc.userMod.controller.UserController@6f195bc3
com.atguigu.ioc.userMod.service.UserServiceImpl@51e2adc7
com.atguigu.ioc.userMod.dao.UserDaoImpl@1a8a8f7c
添加成功

使用注解配置bean

1.项目目录

2.UserController.java

package com.atguigu.ioc.userMod.controller;

import org.springframework.stereotype.Controller;

@Controller
public class UserController {

    public UserController() {
        System.out.println("UserController");
    }
    
}

3.UserDao.java

package com.atguigu.ioc.userMod.dao;

public interface UserDao {

}

4.UserDaoImpl.java(UserDao接口的实现类)

package com.atguigu.ioc.userMod.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao{
    public UserDaoImpl(){
        System.out.println("UserDaoImpl");
    }
}

5.UserService.java

package com.atguigu.ioc.userMod.service;

public interface UserService {

}

6.UserServiceImpl.java(UserService接口的实现类)

package com.atguigu.ioc.userMod.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{

    public UserServiceImpl() {
        System.out.println("UserServiceImpl");
    }

}

7.user.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.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <!-- 
        <context:component-scan>:扫描组件,对设置的包下面的类进行扫描,会将加上注解的类作为spring的组件进行加载
        组件:指spring中管理的bean
        作为spring的组件进行加载:会自动在spring的配置文件中生成相对应的bean,这些bean的id会以类的首字母小写为值
        
        <context:include-filter>:在设定的包结构下再次通过注解或类型具体包含到某个或某几个类
        注意:在使用包含时,一定要设置use-default-filters="false",将默认(即扫描包下所有的类)的过滤关闭
        
        <context:exclude-filter>:在设定的包结构下,再次通过注解或类型具体排除某个或某几个类
        注意:在使用排除时,一定要设置use-default-filters="true",将默认(即扫描包下所有的类)的过滤打开
        
        切记:一个<context:component-scan>中可以出现多个include,也可以同时出现多个exclude,但是两个不能同时出现
     -->
    <context:component-scan base-package="com.atguigu.ioc.userMod" use-default-filters="true">
        <!-- <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> -->
        <!-- <context:include-filter type="assignable" expression="com.atguigu.ioc.userMod.service.UserServiceImpl"/> -->
        <!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/> -->
        <!-- <context:exclude-filter type="assignable" expression="com.atguigu.ioc.userMod.dao.UserDaoImpl"/> -->
    </context:component-scan>
    
    <!-- <bean id="userController" class="com.atguigu.ioc.userMod.controller.UserController"></bean>
    <bean id="userServiceImpl" class="com.atguigu.ioc.userMod.service.UserServiceImpl"></bean>
    <bean id="userDaoImpl" class="com.atguigu.ioc.userMod.dao.UserDaoImpl"></bean> -->
</beans>

8.Test.java

package com.atguigu.ioc.userMod;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.atguigu.ioc.userMod.controller.UserController;
import com.atguigu.ioc.userMod.dao.UserDao;
import com.atguigu.ioc.userMod.dao.UserDaoImpl;
import com.atguigu.ioc.userMod.service.UserService;
import com.atguigu.ioc.userMod.service.UserServiceImpl;

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("user.xml");
        
        UserController uc = ac.getBean("userController", UserController.class);
        System.out.println(uc);//com.atguigu.ioc.userMod.controller.UserController@4b553d26
        
        UserService us = ac.getBean("userServiceImpl", UserServiceImpl.class);
        System.out.println(us);//com.atguigu.ioc.userMod.service.UserServiceImpl@69a3d1d
        
        UserDao ud = ac.getBean("userDaoImpl", UserDaoImpl.class);
        System.out.println(ud);//com.atguigu.ioc.userMod.dao.UserDaoImpl@86be70a
    }
}

自动装配(自动为属性赋值)

1.项目目录

2.Emp.java

package com.atguigu.ioc.auto;

public class Emp {
    private Integer eid;
    private String ename;
    //private Car car;//类型可以写该类以及该类的父类
    private CarExtends car;
    //private Dept dept;//类型可以写该类以及该类的父类
    private DeptI dept;
    public Integer getEid() {
        return eid;
    }
    public void setEid(Integer eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public CarExtends getCar() {
        return car;
    }
    public void setCar(CarExtends car) {
        this.car = car;
    }
    public DeptI getDept() {
        return dept;
    }
    public void setDept(DeptI dept) {
        this.dept = dept;
    }
    @Override
    public String toString() {
        return "Emp [eid=" + eid + ", ename=" + ename + ", car=" + car + ", dept=" + dept + "]";
    }
    
}

3.CarExtends.java(Car的父类)

package com.atguigu.ioc.auto;

public class CarExtends {

}

4.Car.java

package com.atguigu.ioc.auto;

public class Emp {
    private Integer eid;
    private String ename;
    //private Car car;//类型可以写该类以及该类的父类
    private CarExtends car;
    //private Dept dept;//类型可以写该类以及该类的父类
    private DeptI dept;
    public Integer getEid() {
        return eid;
    }
    public void setEid(Integer eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public CarExtends getCar() {
        return car;
    }
    public void setCar(CarExtends car) {
        this.car = car;
    }
    public DeptI getDept() {
        return dept;
    }
    public void setDept(DeptI dept) {
        this.dept = dept;
    }
    @Override
    public String toString() {
        return "Emp [eid=" + eid + ", ename=" + ename + ", car=" + car + ", dept=" + dept + "]";
    }
    
}

5.DeptI.java(接口)

package com.atguigu.ioc.auto;

public interface DeptI {

}

6.Dept.java(DeptI接口的实现类)

package com.atguigu.ioc.auto;

public class Dept implements DeptI{
    private Integer did;
    private String dname;
    public Integer getDid() {
        return did;
    }
    public void setDid(Integer did) {
        this.did = did;
    }
    public String getDname() {
        return dname;
    }
    public void setDname(String dname) {
        this.dname = dname;
    }
}

7.auto.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.xsd">
    
    <!--
        autowire:根据某种策略自动未非字面量属性赋值
        autowire="byName|byType"
        byName:通过属性名和spring容器中bean的id进行比较,若一致则可直接赋值
        byType:通过spring容器中bean的类型,为兼容性(子类对象为父类赋值,实现类为接口赋值)的属性赋值 
                在使用byType的过程中,要求spring容器中只能有一个能为属性赋值的bean
        
        选用建议:当设置autowire属性,会最作用于该bean中所有的非字面量属性,因此谁都不用
     -->
    
    <bean id="emp" class="com.atguigu.ioc.auto.Emp" autowire="byName"><!-- byName/byType -->
        <property name="eid" value="1001"></property>
        <property name="ename" value="张三"></property>
        <!-- <property name="car" ref="car"></property>
        <property name="dept" ref="dept"></property> -->
    </bean>
    
    <bean id="car" class="com.atguigu.ioc.auto.Car">
        <property name="cid" value="666666"></property>
        <property name="cname" value="霸道"></property>
    </bean>
    
    <bean id="dept" class="com.atguigu.ioc.auto.Dept">
        <property name="did" value="1111"></property>
        <property name="dname" value="开发部"></property>
    </bean>
</beans>

8.Test.java

package com.atguigu.ioc.auto;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext ac = new ClassPathXmlApplicationContext("auto.xml");
        
        Emp bean = ac.getBean("emp", Emp.class);
        
        System.out.println(bean);
    }
}

9.运行结果

Emp [eid=1001, ename=张三, car=com.atguigu.ioc.auto.Car@31ef45e3, dept=com.atguigu.ioc.auto.Dept@598067a5]

引用外部属性文件

1.项目目录

2.导入druid-1.1.9.jar、mysql-connector-java-5.1.7-bin.jar

3.db.properties

# k = v
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=123456

4.datasource.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.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <!-- 直接配置 -->
    <!-- <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/test"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean> -->
    
    <!-- 加载资源文件(引用外部资源文件) -->
    <!-- <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="db.properties"></property>
    </bean>
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean> -->
    
    <!-- 使用context标签加载资源文件(引用外部属性文件) -->
    <context:property-placeholder location="db.properties"/>
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="db.properties"></property>
    </bean>
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean> 
</beans>

5.Test.java

package com.atguigu.ioc.datasource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.alibaba.druid.pool.DruidDataSource;

public class Test {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        ApplicationContext ac = new ClassPathXmlApplicationContext("datasource.xml");
        
        DruidDataSource bean = ac.getBean("datasource", DruidDataSource.class);
        
        System.out.println(bean);
        
        //System.out.println(bean.getConnection());
    }

}

bean的生命周期、bean的后置处理器

1.项目目录

2.bean的生命周期(******)
① 通过构造器或工厂方法创建bean实例
② 为bean的属性设置值和对其他bean的引用
③ 调用bean的初始化方法
④ bean可以使用了
⑤ 当容器关闭时,调用bean的销毁方法

3.Person.java

package com.atguigu.ioc.life;

public class Person {
    private Integer id;
    private String sex;
    private String name;
    
    public Integer getId() {
        return id;
    }
    
    public void setId(Integer id) {
        System.out.println("Two:依赖注入");
        this.id = id;
    }
    
    public String getSex() {
        return sex;
    }
    
    public void setSex(String sex) {
        this.sex = sex;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public Person() {
        System.out.println("One:创建对象");
    }
    
    public void init(){
        System.out.println("Three:初始化");
    }
    
    

    @Override
    public String toString() {
        return "Four: Person [id=" + id + ", sex=" + sex + ", name=" + name + "]";
    }

    public void destroy(){
        System.out.println("Five:销毁");
    }
}

4.AfterHandler.java(后置处理器)

package com.atguigu.ioc.life;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class AfterHandler implements BeanPostProcessor{

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        return bean;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        Person person = (Person)bean;
        if(person.getSex().equals("男")){
            person.setName("张无忌");
        }else{
            person.setName("赵敏");
        }
        return person;
    }
 
}

5.life.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.xsd">
    
    <!-- 测试bean的生命周期 -->
    <bean id="person" class="com.atguigu.ioc.life.Person" init-method="init" destroy-method="destroy">
        <property name="id" value="1001"></property>
        <property name="sex" value="男"></property>
    </bean>
    
    <!-- 测试后置处理器 -->
    <bean class="com.atguigu.ioc.life.AfterHandler"></bean>
</beans>

6.Test.java

package com.atguigu.ioc.life;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("life.xml");
        
        Person person = ac.getBean("person", Person.class);
        System.out.println(person);
        
        ac.close();
    }
}

7.运行结果

One:创建对象
Two:依赖注入
Three:初始化
Four: Person [id=1001, sex=男, name=张无忌]
二月 15, 2022 4:34:28 下午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@2dda6444: startup date [Tue Feb 15 16:34:27 CST 2022]; root of context hierarchy
Five:销毁

bean的作用域

1.项目目录

2.Student.java

package com.atguigu.ioc.scope;

public class Student {
    private Integer sid;
    private String sname;
    public Student() {
        System.out.println("Student 无参构造方法");
    }
    public Integer getSid() {
        return sid;
    }
    public void setSid(Integer sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
//    @Override
//    public String toString() {
//        return "Student [sid=" + sid + ", sname=" + sname + "]";
//    }
}

3.scope.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.xsd">
    
    <bean id="student" class="com.atguigu.ioc.scope.Student" scope="singleton">
        <property name="sid" value="1001"></property>
        <property name="sname" value="张三"></property>
    </bean>

</beans>

4.Test.java

package com.atguigu.ioc.scope;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args){
        /**
         * 若spring中有单例模式(singleton)的bean,在初始化容器时就会创建此对象
         * 而多例即原型(prototype)的bean,会在使用时创建
         */
        ApplicationContext ac = new ClassPathXmlApplicationContext("scope.xml");
        
//        Student student1 = ac.getBean("student",Student.class);
//        Student student2 = ac.getBean("student",Student.class);
//        
//        System.out.println(student1);
//        System.out.println(student2);
    }
}

FactoryBean

Spring中有两种类型的bean,一种是普通bean,另一种是工厂bean,即FactoryBean。工厂bean跟普通bean不同,其返回的对象不是指定类的一个实例,其返回的是该工厂bean的getObject方法所返回的对象。
示例:
1.项目目录

2.Car.java

package com.atguigu.spring.factorybean;

public class Car {
    private String brand;
    private Double price;
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    @Override
    public String toString() {
        return "Car [brand=" + brand + ", price=" + price + "]";
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    
}

3.MyFactory.java

package com.atguigu.spring.factorybean;

import org.springframework.beans.factory.FactoryBean;

public class MyFactory implements FactoryBean<Car>{
    @Override
    public Car getObject() throws Exception {
        Car car = new Car();
        car.setBrand("奥迪");
        car.setPrice(200000.0);
        return car;
    }

    @Override
    public Class<?> getObjectType() {
        return Car.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

4.factory-bean.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.xsd">
    
    <!-- 工厂bean -->
    <bean id="factory" class="com.atguigu.spring.factorybean.MyFactory"></bean>
</beans>

5.Test.java

package com.atguigu.spring.factorybean;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext ac = new ClassPathXmlApplicationContext("factory-bean.xml");
        Object bean = ac.getBean("factory");
        System.out.println(bean);
    }
}

6.运行结果
Car [brand=奥迪, price=200000.0]

属性赋值-字面量和ref

spring管理对象时,可以使用标签给对象的属性赋值。
1.字面量


…..
2.外部已声明的bean引用其他的bean(使用ref属性)
3.内部bean
4.集合属性赋值(list/array/set)
示例:
1.项目目录

2.Student.java

package com.atguigu.spring.di;

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private Double score;
    private Teacher teacher;
    
    
    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public Double getScore() {
        return score;
    }
    
    public void setScore(Double score) {
        this.score = score;
    }
    
    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;
    }
    
    public Integer getAge() {
        return age;
    }
    
    public void setAge(Integer age) {
        this.age = age;
    }
    
    public String getSex() {
        return sex;
    }
    
    public void setSex(String sex) {
        this.sex = sex;
    }
    
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", score=" + score
                + ", teacher=" + teacher + "]";
    }

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    public Student(Integer id, String name, Integer age, String sex) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    
    public Student(Integer id, String name, Double score, String sex){
        this.id = id;
        this.name = name;
        this.score = score;
        this.sex = sex;
    }
}

3.Teacher.java

package com.atguigu.spring.di;

import java.util.List;
import java.util.Map;

public class Teacher {
    private Integer tid;
    
    private String tname;
    
    private List<String> cls;
    
    private List<Student> students;
    
    private Map<String, String> bossMap;
    
    public Map<String, String> getBossMap() {
        return bossMap;
    }
    public void setBossMap(Map<String, String> bossMap) {
        this.bossMap = bossMap;
    }
    public List<Student> getStudents() {
        return students;
    }
    public void setStudents(List<Student> students) {
        this.students = students;
    }
    public List<String> getCls() {
        return cls;
    }
    public void setCls(List<String> cls) {
        this.cls = cls;
    }
    public Integer getTid() {
        return tid;
    }
    public void setTid(Integer tid) {
        this.tid = tid;
    }
    public String getTname() {
        return tname;
    }
    public void setTname(String tname) {
        this.tname = tname;
    }
    @Override
    public String toString() {
        return "Teacher [tid=" + tid + ", tname=" + tname + ", cls=" + cls + ", students=" + students + ", bossMap="
                + bossMap + "]";
    }
    
    
}

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

    <bean id="s1" class="com.atguigu.spring.di.Student">
        <!-- 通过set方法注入 -->
        <property name="id" value="10010"></property>
        <!-- 
            <property name="id">
                <value>10010</value>
            </property>
         -->
         
        <property name="name" value="张三"></property>
        <property name="age" value="23"></property>
        <property name="sex" value="男"></property>
    </bean>
        
    <bean id="s2" class="com.atguigu.spring.di.Student">
        <!-- 通过构造方法注入 -->
        <constructor-arg value="10086"></constructor-arg>
        <constructor-arg value="李四"></constructor-arg>
        <constructor-arg value="24"></constructor-arg>
        <constructor-arg value="女"></constructor-arg>
    </bean>
    
    <bean id="s3" class="com.atguigu.spring.di.Student">
        <!-- 通过构造方法注入 -->
        <constructor-arg value="10022"></constructor-arg>
        <constructor-arg value="王五"></constructor-arg>
        <constructor-arg value="90" index="2" type="java.lang.Double"></constructor-arg>
        <constructor-arg value="女"></constructor-arg>
    </bean>
    
    <!-- Namespaces勾选p(beans标签会增加内容xmlns:p="http://www.springframework.org/schema/p") -->
    <bean id="s4" class="com.atguigu.spring.di.Student" p:id="10033" p:name="赵六" p:age="26" p:sex="男" p:teacher-ref="teacher"></bean>
    
    <!-- 给bean的级联属性赋值 -->
    <bean id="s5" class="com.atguigu.spring.di.Student">
        <property name="id" value="10055"></property>
        <property name="name" value="张三三"></property>
        <property name="age" value="23"></property>
        <property name="sex" value="男"></property>
        <property name="teacher" ref="teacher"></property>
        
        <!-- 级联测试 给bean的级联属性赋值-->
        <property name="teacher.tname" value="小红"></property>
    </bean>
        
    <!-- 外部已声明的bean、引用其他的bean -->
    <bean id="teacher" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="10000"></property>
        <property name="tname" value="小明"></property>
    </bean>
    
    <!-- 内部bean -->
    <bean id="s6" class="com.atguigu.spring.di.Student">
        <property name="id" value="10066"></property>
        <property name="name" value="崔八"></property>
        <property name="age" value="18"></property>
        <property name="sex" value="男"></property>
        <property name="teacher">
            <bean id="tt" class="com.atguigu.spring.di.Teacher">
                <property name="tid" value="2222"></property>
                <property name="tname" value="admin"></property>
            </bean>
        </property>
    </bean>
    <!-- 定义在某个bean内部的bean,只能在当前bean中使用 -->
    <!-- 
        <bean id="s7" class="com.atguigu.spring.di.Student">
            <property name="id" value="10066"></property>
            <property name="name" value="崔八"></property>
            <property name="age" value="18"></property>
            <property name="sex" value="男"></property>
            <property name="teacher" ref="tt">
            </property>
        </bean>
     -->
     
     <!-- list属性赋值1 -->
     <bean id="t1" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="0000"></property>
        <property name="tname" value="佟老师"></property>
        <property name="cls">
            <list>
                <value>A</value>
                <value>B</value>
                <value>C</value>
            </list>
        </property>
     </bean>
     
     <!-- list属性赋值2 -->
     <bean id="t2" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="10002"></property>
        <property name="tname" value="婷姐"></property>
        <property name="students">
            <list>
                <ref bean="s1"/>
                <ref bean="s2"/>
                <ref bean="s3"/>
            </list>
        </property>
     </bean>
     
     <!-- array属性赋值 -->
     <!-- set属性赋值 -->
     
     <!-- map属性赋值 -->
     <bean id="t3" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="10003"></property>
        <property name="tname" value="admin"></property>
        <property name="bossMap">
            <map>
                <entry>
                    <key>
                        <value>10001</value>
                    </key>
                    <value>佟老师</value>
                </entry>
                
                <entry>
                    <key>
                        <value>10002</value>
                    </key>
                    <value>陈老师</value>
                </entry>
            </map>
        </property>
     </bean>
     
     <bean id="t4" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="10004"></property>
        <property name="tname" value="root"></property>
        <property name="students" ref="students"></property>
     </bean>
    
    <util:list id="students">
        <ref bean="s4"/>
        <ref bean="s5"/>
        <ref bean="s6"/>
    </util:list>
    
    <util:map id="map">
        <entry>
            <key>
                <value>1</value>
            </key>
            <value>张三</value>
        </entry>
    </util:map>
</beans>

6.Test.java

package com.atguigu.spring.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans-di.xml");
        
        Student s1 = ac.getBean("s1", Student.class);
        Student s2 = ac.getBean("s2", Student.class);
        Student s3 = ac.getBean("s3", Student.class);
        Student s4 = ac.getBean("s4", Student.class);
        Student s5 = ac.getBean("s5", Student.class);
        Student s6 = ac.getBean("s6", Student.class);
        Teacher t1 = ac.getBean("t1", Teacher.class);
        Teacher t2 = ac.getBean("t2", Teacher.class);
        Teacher t3 = ac.getBean("t3", Teacher.class);
        Teacher t4 = ac.getBean("t4", Teacher.class);
        
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println(s5);
        System.out.println(s6);
        System.out.println(t1);
        System.out.println(t2);
        System.out.println(t3);
        System.out.println(t4);
    }
}

依赖注入的两种方式

  1. 通过bean的setXxx()方法赋值
  2. 通过bean的构造器赋值

    示例

  3. 项目目录

2.创建Student.java

package com.atguigu.spring.di;

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private Double score;
    public Double getScore() {
        return score;
    }
    public void setScore(Double score) {
        this.score = score;
    }
    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;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", score=" + score + "]";
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(Integer id, String name, Integer age, String sex) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    
    public Student(Integer id, String name, Double score, String sex){
        this.id = id;
        this.name = name;
        this.score = score;
        this.sex = sex;
    }
}

3.创建beans-di.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: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="s1" class="com.atguigu.spring.di.Student">
        <!-- 通过set方法注入 -->
        <property name="id" value="10010"></property>
        <property name="name" value="张三"></property>
        <property name="age" value="23"></property>
        <property name="sex" value="男"></property>
    </bean>
        
    <bean id="s2" class="com.atguigu.spring.di.Student">
        <!-- 通过构造方法注入 -->
        <constructor-arg value="10086"></constructor-arg>
        <constructor-arg value="李四"></constructor-arg>
        <constructor-arg value="24"></constructor-arg>
        <constructor-arg value="女"></constructor-arg>
    </bean>
    
    <bean id="s3" class="com.atguigu.spring.di.Student">
        <!-- 通过构造方法注入 -->
        <constructor-arg value="10022"></constructor-arg>
        <constructor-arg value="王五"></constructor-arg>
        <constructor-arg value="90" index="2" type="java.lang.Double"></constructor-arg>
        <constructor-arg value="女"></constructor-arg>
    </bean>

    <!-- Namespaces勾选p(beans标签会增加内容xmlns:p="http://www.springframework.org/schema/p") -->
    <bean id="s4" class="com.atguigu.spring.di.Student" p:id="10033" p:name="赵六" p:age="26" p:sex="男"></bean>
</beans>

4.编写测试类

package com.atguigu.spring.di;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans-di.xml");
        
        Student s1 = ac.getBean("s1", Student.class);
        Student s2 = ac.getBean("s2", Student.class);
        Student s3 = ac.getBean("s3", Student.class);
        Student s4 = ac.getBean("s4", Student.class);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
    }

}

spring简单案例

使用软件:STS

下载地址

搭建spring运行时环境

1.加入JAR包
1)Spring自身JAR包:spring-framework-4.0.0.RELEASE\libs目录下
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELE2ASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar
2)commons-logging-1.1.1.jar
注:将以上所有的jar包复制到项目中的lib目录下并全选所有jar包–>右键–>build path–>config bulid path
2.在Spring Tool Suite工具中通过如下步骤创建Spring的配置文件
1)File->New->Spring Bean Configuration File
2)为文件取名字 例如:applicationContext.xml

创建一个类:Person.java

package com.atguigu.spring.mod;

public class Person {
    private Integer id;
    private String 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 "Person [id=" + id + ", name=" + name + "]";
    }
    
}

常规方法操作对象

创建一个测试类Test.java

package com.atguigu.spring.mod;

public class Test {
    public static void main(String[] args){
        Person person = new Person();
        person.setId(1);
        person.setName("zhangsan");
        System.out.println(person);
    }
}

spring管理对象

1.创建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.xsd">

    <!-- 命名空间 规定当前的文件里面能写什么-->

    <!--
        <bean>:定义spring管理的一个对象
        id:该对象的唯一标识,注意不能重复,在类型获取bean的过程中可以不设置
        class:该对象所属类的全限定名 
    -->
    
    <!-- 通过反射创建对象 -->
    <bean id="person" class="com.atguigu.spring.mod.Person">
        <!--
            <property>:为对象的某个属性赋值
            name:属性名
            value:属性值 
        -->
        <property name="id" value="1111"></property>
        <property name="name" value="小明"></property>
    </bean>
    
</beans>

2.创建一个测试类TestBySpring.java

package com.atguigu.spring.mod;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBySpring {

    public static void main(String[] args) {
        //初始化容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        //通过getBean()获取对象
        Person person = (Person) ac.getBean("person");
        System.out.println(person);

    }
}

注:IOC和DI
反转控制(IOC):对象的管理权(创建、赋值等)由程序员交给了spring容器
依赖注入(DI):bean对象依赖于属性 向属性注入资源(赋值)
总结: IOC 就是一种反转控制的思想, 而DI是对IOC的一种具体实现。