Spring IoC容器与Bean管理项目实践指南_Java

代码结构

spring01/
├── pom.xml
├── spring01.iml
└── src/
    ├── main/
    │   ├── java/
    │   │   └── com/
    │   │       └── demo/
    │   │           ├── bean/
    │   │           │   ├── demo.java
    │   │           │   ├── emp1.java
    │   │           │   ├── emp2.java
    │   │           │   └── user.java
    │   │           ├── dao/
    │   │           │   ├── userdao.java
    │   │           │   └── impl/
    │   │           │       ├── mysqluserdaoimpl.java
    │   │           │       └── oracleuserdaoimpl.java
    │   │           ├── factory/
    │   │           │   ├── emp1factory.java
    │   │           │   ├── emp2factory.java
    │   │           │   └── userdaofactory.java
    │   │           ├── service/
    │   │           │   ├── userservice.java
    │   │           │   └── impl/
    │   │           │       └── userserviceimpl.java
    │   │           └── test/
    │   │               └── usertest.java
    │   └── resources/
    │       ├── userdao.properties
    │       ├── applicationcontext-实例工厂创建bean.xml
    │       ├── applicationcontext-普通构建方法创建bean.xml
    │       ├── applicationcontext-静态工厂创建bean.xml
    │       ├── applicationcontext.xml
    │       └── logback.xml
    └── test/
		└── java/
		    └── com/
		        └── demo/
		            ├── loggertest.java
		            ├── testdemo.java
		            └── usertest.java

该项目是一个spring框架练习项目，主要围绕以下核心目标进行实践：

一、核心技术练习

spring ioc容器与bean管理
- 实现了多种bean创建方式（普通构造方法、静态工厂、实例工厂）
- 对应配置文件：applicationcontext-*.xml系列文件
设计模式应用
- 工厂模式：通过emp1factory、emp2factory等类实现对象创建封装
- 接口编程：userdao接口+mysql/oracle多实现类

分层架构实践

com.demo
├── bean      // 数据模型层（user.java等实体类）
├── dao       // 数据访问层（数据库操作接口及实现）
├── service   // 业务逻辑层（服务接口及实现）
└── factory   // 对象工厂层（创建bean的工厂类）

二、功能模块说明

数据访问：通过userdao及实现类操作数据库，支持多数据库类型（mysql/oracle）
依赖注入：使用spring容器管理对象依赖关系
日志系统：集成logback日志框架（logback.xml配置）
配置管理：通过userdao.properties实现配置外部化

三、测试覆盖

单元测试：loggertest（日志测试）、usertest（用户功能测试）等测试类
测试规范：遵循与主代码相同的包结构，确保测试代码可维护性

四、项目特点

性质：通过多种配置文件和工厂类展示不同实现方式
结构清晰：严格遵循maven项目规范和分层架构设计
可扩展性：通过接口和工厂模式预留功能扩展点

该项目适合初学者理解spring核心概念、设计模式应用及企业级项目分层架构思想。

实体类 bean

package com.demo.bean;

import java.util.list;
import java.util.map;
import java.util.properties;
import java.util.set;

public class demo {
    private list<string> list;
    private set<string> set;
    private map<string,string> map;
    private properties properties;

    public list<string> getlist() {
        return list;
    }

    public void setlist(list<string> list) {
        this.list = list;
    }

    public set<string> getset() {
        return set;
    }

    public void setset(set<string> set) {
        this.set = set;
    }

    public map<string, string> getmap() {
        return map;
    }

    public void setmap(map<string, string> map) {
        this.map = map;
    }

    public properties getproperties() {
        return properties;
    }

    public void setproperties(properties properties) {
        this.properties = properties;
    }
}
package com.demo.bean;

public class emp1 {
    public  void update1(){
        system.out.println("emp1的update1（）方法被调用。。。  。。。");
    }
}
package com.demo.bean;

public class emp2 {
    public  void update2(){
        system.out.println("emp2的update2（）方法被调用。。。  。。。");
    }
}
package com.demo.bean;

public class user {
    private  integer userid;
    private  string username;
    private  string password;

    public integer getuserid() {
        return userid;
    }

    public void setuserid(integer userid) {
        this.userid = userid;
    }

    public string getusername() {
        return username;
    }

    public void setusername(string username) {
        this.username = username;
    }

    public string getpassword() {
        return password;
    }

    public void setpassword(string password) {
        this.password = password;
    }

    @override
    public string tostring() {
        return "user{" +
                "userid=" + userid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

dao层

import com.demo.bean.user;

public interface userdao {
    public  boolean updateuser(user user);
}

import com.demo.bean.user;
import com.demo.dao.userdao;
import org.slf4j.logger;
import org.slf4j.loggerfactory;

public class mysqluserdaoimpl implements userdao {
    @override
    public boolean updateuser(user user) {
        logger logger = loggerfactory.getlogger(mysqluserdaoimpl.class);
        logger.info("mysql正在进行修改操作:updateuser();");
        return true;
    }
}

import com.demo.bean.user;
import com.demo.dao.userdao;
import org.slf4j.logger;
import org.slf4j.loggerfactory;

public class oracleuserdaoimpl implements userdao {
    @override
    public boolean updateuser(user user) {
        logger logger = loggerfactory.getlogger(oracleuserdaoimpl.class);
        logger.info("oracle正在进行修改操作:updateuser();");
        return true;
    }
}

简单工厂模式

import com.demo.bean.emp1;

public class emp1factory {
public static emp1 getinstance(){
    return new emp1();
}
}

package com.demo.factory;

import com.demo.bean.emp2;

public class emp2factory {
    public emp2 getinstance() {
        return new emp2();
    }
}


package com.demo.factory;

import com.demo.dao.userdao;

import java.io.inputstream;
import java.util.properties;

public class userdaofactory {

    public  userdao getinstance() {
        userdao userdao = null;
        try {
            //读取属性文件
            properties properties = new properties();
            inputstream in = userdaofactory.class.getclassloader().getresourceasstream("userdao.properties");
            properties.load(in);
            //通过key获取全名字符串
            string userdaofullname = properties.getproperty("userdao");
            //通过反射获取类的实例对象
            userdao = (userdao) class.forname(userdaofullname).newinstance();
        } catch (
                exception e) {
            e.printstacktrace();
        }
        return userdao;
    }
}

service层

import com.demo.bean.user;

public interface userservice {
   public boolean updateuser(user user);
}

package com.demo.service.impl;

import com.demo.bean.user;
import com.demo.dao.userdao;
import com.demo.factory.userdaofactory;
import com.demo.service.userservice;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;

/**
 * 1.userdao 的实现类不由userserviceimpl来决定,而是由userdaofactory来决定<第一种>
 * 2.控制权从userserviceimpl转移到了userdaofactory,这就是控制反转ioc/di
 */
@service
public class userserviceimpl  implements userservice{
   /** 
   <第一种>
   userdaofactory userdaofactory=new userdaofactory();
    userdao userdao=userdaofactory.getinstance();*/
    @autowired
	private   userdao userdao;
	
    public void setuserdao(userdao userdao) {
        this.userdao = userdao;
    }
    // private userdao userdao=new userdaofactory.getinstance();//报错
   // private userdao userdao=new mysqluserdaoimpl();
   //private userdao userdao=new oracleuserdaoimpl();

    @override
    public boolean updateuser(user user) {
        return userdao.updateuser(user);
    }
}

测试

日志测试

import org.junit.test;
import org.slf4j.logger;
import org.slf4j.loggerfactory;

public class loggertest {
    @test
    public void loggertest() {
        //system.out.println(loggerfactory.getlogger("hello"));

        logger logger = loggerfactory.getlogger(loggertest.class);

        //slf4j日志的级别
        logger.trace("trace");
        logger.debug("debug");
        logger.info("info");
        logger.warn("warn");
        logger.error("error");

        //拼接
        logger.info("welcome to {} {} ", "www.51zxw.net", "go!");
    }

}

测试 applicationcontext.xml 配置文件的配置

package com.demo;

import com.demo.bean.demo;
import org.junit.test;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;

import java.util.*;

public class testdemo {
    logger logger = loggerfactory.getlogger(loggertest.class);

    @test
    public void testdemo() {
        applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
        demo demo = (demo) context.getbean("demo");
        list<string> list = demo.getlist();
        logger.info("list----------------------");
        for (string s : list) {
            logger.info(s);
        }
        logger.info("set----------------------");
        set<string> set = demo.getset();
        for (string s : set) {
            logger.info(s);
        }
        logger.info("map----------------------");
        map<string, string> map = demo.getmap();
        set<string> keyset = map.keyset();
        iterator<string> iterator = keyset.iterator();
        while (iterator.hasnext()) {
            string key = iterator.next();
            string value = map.get(key);
            logger.info(key + "  " + value);
        }
        logger.info("properties----------------------");
        properties properties = demo.getproperties();
        string userid = properties.getproperty("userid");
        string username = properties.getproperty("username");
        string password = properties.getproperty("password");
        logger.info(userid);
        logger.info(username);
        logger.info(password);
    }
}

测试其他集中配置文件管理bean

package com.demo;

import com.demo.bean.emp1;
import com.demo.bean.emp2;
import com.demo.bean.user;
import com.demo.dao.userdao;
import com.demo.service.userservice;
import org.junit.test;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;

/**
 * 1.从springioc容器工厂中获取一个user对象
 * a。获取工厂beanfactory
 * b。getbean()返回对象
 * 2.applicationcontext是beanfactory的子接口（实际上也是工厂）
 */
public class usertest {
    logger logger = loggerfactory.getlogger(loggertest.class);

    /**
     * 测试普通构造方法创建的bean
     */
    @test
    public void usertest() {
        //获取beanfactory的子接口，它是用来获得配置在springioc容器的对象
        applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
        //从springioc容器工厂中获取一个user对象
        user user = (user) context.getbean("user");
        if (null != user) {
            logger.info(user.tostring());
        }
    }

    /**
     * 测试普通构造方法创建的bean
     */
    @test
    public void userdaotest() {
        //获取beanfactory的子接口，它是用来获得配置在springioc容器的对象
        applicationcontext context = new classpathxmlapplicationcontext("applicationcontext-实例工厂创建bean.xml");
        //从springioc容器工厂中获取一个user对象
        userdao userdao = (userdao) context.getbean("userdao");
        if (null != userdao) {
            userdao.updateuser(null);
        }
    }

    /**
     * 静态工厂创建bean
     */
    @test
    public void emp1test() {
        //获取beanfactory的子接口，它是用来获得配置在springioc容器的对象
        applicationcontext context = new classpathxmlapplicationcontext("applicationcontext-实例工厂创建bean.xml");
        //从springioc容器工厂中获取一个user对象
        emp1 emp1 = (emp1) context.getbean("emp1");
        if (null != emp1) {
            emp1.update1();
        }
    }

    /**
     * 实例工厂创建bean
     */
    @test
    public void emp2test() {
        //获取beanfactory的子接口，它是用来获得配置在springioc容器的对象
        applicationcontext context = new classpathxmlapplicationcontext("applicationcontext-实例工厂创建bean.xml");
        //从springioc容器工厂中获取一个user对象
        emp2 emp2 = (emp2) context.getbean("emp2");
        if (null != emp2) {
            emp2.update2();
        }
    }

    @test
    public void userservicetest() {
        //获取beanfactory的子接口，它是用来获得配置在springioc容器的对象
        applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
        //从springioc容器工厂中获取一个user对象
        userservice userservice = (userservice) context.getbean("userservice");
        if (null != userservice) {
            userservice.updateuser(null);
        }
    }
}

测试第一种被userdaofactory来决定实现的方式

要解开注解，userserviceimpl代码改为

    userdaofactory userdaofactory=new userdaofactory();
    userdao userdao=userdaofactory.getinstance();
//    @autowired
//    private  userdao userdao;
// 其余不变

package com.demo.test;

import com.demo.bean.user;
import com.demo.service.userservice;
import com.demo.service.impl.userserviceimpl;

public class usertest {
    public static void main(string[] args) {
        userservice userservice=new userserviceimpl();
        user user=new user();
        userservice.updateuser(user);
    }
}

配置文件

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 id="user" class="com.demo.bean.user">
        <!--  为对象注入属性值   -->
        <property name="userid" value="1"></property>
        <property name="username" value="张三"></property>
        <property name="password" value="123456"></property>
    </bean>
    <!-- 1.创建属性对象mysqluserdaoimpl（如果是besn类型）
      a.必须添加setter（）方法注入属性；
      b.通过构造方法注入属性
      2.创建userservice
      -->
    <bean id="userdao" class="com.demo.dao.impl.mysqluserdaoimpl"></bean>
    <bean id="userservice" class="com.demo.service.impl.userserviceimpl">
        <!--    ref是通过引用userdao，然后找到实现类    -->
        <property name="userdao" ref="userdao"></property>
    </bean>
    <!--
    集合属性的注入：
    list:添加list节点，然后如果集合中的数据是引用数据类型需要使用ref节点，如果是基本数据类型用value
    set:添加set节点，然后如果集合中的数据是引用数据类型需要使用ref节点，如果是基本数据类型用value
    map:添加map节点，由于map中储存的是key和value键值对，需要添加一个entry节点
    对应key，如果数据是引用数据类型需要使用ref节点，如果是基本数据类型用value
    对应value，如果数据是引用数据类型需要使用ref节点，如果是基本数据类型用value
    properties：添加props节点，然后在添加prop
    -->

    <bean id="demo" class="com.demo.bean.demo">
        <property name="list">
            <list>
                <value>乔丹</value>
                <value>科比</value>

                <!--<bean>ref的配置</bean>-->
                <!--                <ref>如果是类类型，或者引用数据类型，需要ref</ref>-->
            </list>
        </property>
        <property name="set">
            <set>
                <value>姚明</value>
                <value>易建联</value>
                <value>王致和</value>
            </set>
        </property>

        <property name="map">
            <map>
                <entry>
                    <key>
                        <value>001</value>
                    </key>
                    <value>篮球</value>
                </entry>
                <entry>
                    <key>
                        <value>002</value>
                    </key>
                    <value>足球</value>
                </entry>
                <entry>
                    <key>
                        <value>003</value>
                    </key>
                    <value>乒乓球</value>
                </entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="userid">1</prop>
                <prop key="username">test</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>
</beans>

applicationcontext-实例工厂创建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
    1.创建emp2
    2.创建emp2factory静态工厂
    3.编写配置文件，注意和普通工厂对比，多两个属性配置factory-method="静态方法名"
    factory-bean属性的配置


    总结：相比普通构造方法创建bean而言稍微麻烦一些，所以很少用
    -->
    <bean id="emp2factory" class="com.demo.factory.emp2factory"></bean>
    <bean id="emp2" factory-bean="emp2factory" factory-method="getinstance"></bean>
</beans>

applicationcontext-普通构建方法创建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">
    <!--    spring容器-->
    <!--采用普通的构造方法来创建bean-->
    <bean id="userservice" class="com.demo.service.impl.userserviceimpl"></bean>
    <bean id="userdao" class="com.demo.dao.impl.mysqluserdaoimpl"></bean>
    <!-- 采用普通的构建方法创建user-->
    <bean id="user" class="com.demo.bean.user"></bean>

</beans>

applicationcontext-静态工厂创建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
1.创建emp1
2.创建emp1factory静态工厂
3.编写配置文件，注意和普通工厂对比，多一个属性配置factory-method="静态方法名"

总结：相比普通构造方法创建bean而言稍微麻烦一些，所以很少用
-->
<bean id="emp1" class="com.demo.factory.emp1factory" factory-method="getinstance"></bean>

</beans>

logback.xml

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <!--输出日志到控制台 appender追加-->
    <appender name="consolelog" class="ch.qos.logback.core.consoleappender">
        <!--负责把事件转成字符串，格式化日志信息的输出-->
        <layout>
            <pattern>
                <!--%p是日志优先级%d是日期，%msg是日志消息%n换行-->
                [%p]%d-%msg%n
            </pattern>
        </layout>
    </appender>
    <appender name="filelog" class="ch.qos.logback.core.rolling.rollingfileappender">
        <filter class="ch.qos.logback.classic.filter.levelfilter">
            <level>debug</level>
            <onmatch>deny</onmatch>
        </filter>
        <encoder>
            <pattern>
                [%p]%d-%msg%n
            </pattern>
        </encoder>
        <!-- 指定文件的输出位置-->
        <rollingpolicy class="ch.qos.logback.core.rolling.timebasedrollingpolicy">
            <filenamepattern>

            </filenamepattern>
        </rollingpolicy>
    </appender>
<!-- 控制台可以输出的级别   -->
    <root level="info">
        <appender-ref ref="consolelog"></appender-ref>
        <appender-ref ref="filelog"></appender-ref>
    </root>
</configuration>

userdao.properties

userdao=com.demo.dao.impl.oracleuserdaoimpl

总结

到此这篇关于spring ioc容器与bean管理的文章就介绍到这了,更多相关spring ioc容器与bean管理内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

Spring IoC容器与Bean管理项目实践指南

2025年08月08日 • Java •我要评论