Spring IOC

最新推荐文章于 2025-09-10 16:19:25 发布

原创最新推荐文章于 2025-09-10 16:19:25 发布 · 134 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #Ioc #控制反转

Spring 专栏收录该内容

5 篇文章

订阅专栏

本文介绍了Spring框架，它是开源轻量级一站式框架，核心包括AOP和IOC。重点阐述了Spring的IOC操作，有配置文件和注解两种方式，还给出无配置文件全注解案例。同时说明了IOC底层原理，以及IOC和DI的区别，前者是对象创建交Spring，后者是属性注入。

3.无配置文件全注解案例

spring概念

spring是开源的轻量级框架:（代码免费公开，使用时没有必要引入其他很多东西）

spring核心主要俩部分: 1. aop:面向切面编程，扩展功能不是修改源代码实现

2. ioc:控制反转，把对象的创建不是通过new方式实现，而是交给spring配置创建类对象

spring是一站式框架：spring在javaee三层结构中，每一层都是提供不同的解决技术。

1.web层:springMvc

2.service层：spring的ioc

3.dao层：spring的jdbcTemplate

spring的ioc操作

ioc操作俩部分：1. 配置文件方式 2.注解方式

1.ioc配置文件方式

ioc底层原理：1.xml配置文件 2.dom4j解析xml文件 3.工厂设计模式 4. 反射

以前调用一个类的方法，传统方式是new出对象，再通过对象调用方法，这样如果类名修改，需要修改源代码，耦合度太高，

为了解耦，出现了工厂模式，通过工厂去创建类，但是又提高了工厂和实体类的耦合度。再后来出现了ioc，ioc原理如下：

在spring项目的resources里创建spring配置文件，名字可以自己指定，这里起名spring_config.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">
    <!-- ioc：bean实例化三种方式：1.无参构造 2.静态工厂 3.实例工厂#########################################-->
    <!--bean实例化方式一：无参构造 -->
    <bean id="user1" class="com.spring.ljj.User"></bean>
    <!--bean实例化方式二：静态工厂 -->
    <bean id="user2" class="com.spring.ljj.StaticFactory" factory-method="getUser"/>
    <!--bean实例化方式三：实例工厂 -->
    <bean id="instanceFactory" class=" com.spring.ljj.InstanceFactory"/>
    <bean id="user3" factory-bean="instanceFactory" factory-method="getUser"/>
    <!--
          bean常用属性 scope
          singleton ：默认单例
          prototype(设置了此值，每次获取对象地址都不一样):多例
          request：创建后放入request
          session:创建后放入session
    -->
    <bean id="user0" name="user0" class="com.spring.ljj.User" scope="singleton"/>
    <!-- DI 属性注入:1.set方法 2.有参构造方法##############################################################-->
    <!-- DI 属性注入方式一：set方法 -->
    <bean id="user4" class="com.spring.ljj.User">
        <property name="userName" value="张红"/>
    </bean>
    <!-- DI 属性注入方式一：有参构造方法 -->
    <bean id="user5" class="com.spring.ljj.User">
        <constructor-arg name="userName" value="李明"/>
    </bean>
    <!-- 注入实体类对象，list,map,set,property-->
    <!-- 注入实体类对象： ref表示引用-->
    <bean id="person" class="com.spring.ljj.Person"/>
    <bean id="user6" class="com.spring.ljj.User">
        <property name="person" ref="person"/>
    </bean>
    <!-- 注入数组-->
    <bean id="user7" class="com.spring.ljj.User">
       <property name="strarr">
           <list>
               <value>arr1</value>
               <value>arr2</value>
           </list>
       </property>
    </bean>
    <!-- 注入list-->
    <bean id="user8" class="com.spring.ljj.User">
        <property name="list">
            <list>
                <value>str1</value>
                <value>str2</value>
            </list>
        </property>
    </bean> 
    <!-- 注入map-->
    <bean id="user9" class="com.spring.ljj.User">
        <property name="map">
            <map>
                <entry key="key1" value="value1"></entry>
                <entry key="key2" value="value2"></entry>
            </map>
        </property>
    </bean>
   <!-- 注入properties-->
    <bean id="user10" class="com.spring.ljj.User">
       <property name="properties">
           <props>
               <prop key="key1">properties1</prop>
               <prop key="key2">properties2</prop>
           </props>
       </property>
    </bean>
</beans>

测试xml方式ioc.

public class TestIoc {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring_config.xml");
        User user1 = (User) applicationContext.getBean("user1");
        System.out.println(user1.getPerson());
        System.out.println(user1.getList());
        System.out.println(user1.getMap());
        System.out.println(user1.getProperties());
        System.out.println(user1.getStrarr());
    }
}

运行结果：

IOC和DI的区别：

ioc:指的是对象创建交给spring

DI:指的是依赖注入，即属性注入。不能单独存在，需要再ioc基础之上完成.

2.ioc注解方式

@Repository
public class UserDao {
    public void getUser() {
        System.out.println("----------->" + new User().toString());
    }
}

@Service
public class UserService {
    @Resource
    private UserDao userDao;

    public void getUser() {
        this.userDao.getUser();
    }
}

测试注解方式实现ioc：

public class TestIoc {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config2.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        System.out.println(userService);
        userService.getUser();
    }
}

运行结果：

无配置文件全注解案例

@Repository
public class UserDao {
    public void sout() {
        System.out.println("userDao");
    }
}


@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    public void sout() {
        this.userDao.sout();
        System.out.println("userService");
    }
}

@ComponentScan
@Configuration
public class App {
}

测试：

public class AppTest1 {
    @Test
    public void test() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(App.class);
        UserService bean = context.getBean(UserService.class);
        bean.sout();
    }
}

另外：引入spring-test依赖，测试就没必要自己初始化spring容器了

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = App.class)
public class AppTest {
    @Autowired
    private UserService userService;

    @Test
    public void test() {
        this.userService.sout();
    }
}