Spring学习（一）Spring简介、SpringIOC

最新推荐文章于 2025-03-22 01:18:04 发布
最新推荐文章于 2025-03-22 01:18:04 发布
阅读量321 收藏
点赞数
分类专栏： Spring 文章标签： Hello，Spring SpringIOC IOC创建对象的方式 依赖注入 Java配置Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42492089/article/details/104468174
版权
一、什么是Spring？
1、简介

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

Spring依赖导入：

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
    </dependencies>
2、Spring的优点
  • Spring是一个开源免费的框架（容器）！
  • Spring是一个轻量级、非入侵式的框架。
  • Spring的两大特点：IOC（控制翻转）和AOP（面向切面编程）！
3、Spring的七大模块

Spring有七大功能模块，分别是:

Spring Core，AOP，ORM，DAO，MVC，WEB，Content。
二、Spring IOC 推导

准备工作：写好各层的接口、实体等

pojo:User

package com.zyh.pojo;

public class User {
    private String name;

    public User() {
        System.out.println("无参构造器");
    }

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

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

dao:UserMapper、UserMapperImp

//UserMapper
package com.zyh.dao;
public interface UserMapper {
    public void getUser();
}

//UserMapperImp
package com.zyh.dao.daoimp;

import com.zyh.dao.UserMapper;

public class UserMapperImp implements UserMapper {
    public void getUser() {
        System.out.println("获取用户数据");
    }
}

Service:UserService、UserServiceImp

//UserService
package com.zyh.service;

public interface UserService {
    public void getUser();
}
//UserServiceImp
package com.zyh.service.serviceimp;

import com.zyh.dao.UserMapper;
import com.zyh.dao.daoimp.UserMapperImp;
import com.zyh.service.UserService;

public class UserServiceImp implements UserService {
    private UserMapper userMapper = new UserMapperImp();
    public void getUser() {
        userMapper.getUser();
    }
}

测试：

package com.zyh.dao;

import com.zyh.dao.daoimp.UserMapperImp;
import com.zyh.dao.daoimp.UserMapperMysqlImp;
import com.zyh.service.UserService;
import com.zyh.service.serviceimp.UserServiceImp;
import org.junit.Test;

public class TestIOC {
    @Test
    public void test1(){
        UserService userService = new UserServiceImp();
        userService.getUser();
    }
}

执行结果：
在这里插入图片描述

这是我们的原生代码，可以获取到当前数据，但是现在如果用户的需求发生了改变，不需要获取当前的数据，而是在接口层新增了一个新的接口UserMapperMysqlIml ，那么我们就需要再去service
层再去修改代码呢，这就不符合我们现在Spring开发的思想，在Spring中我们说怎么去做呢？

  • 修改Service层的代码，增加一个setUserMapper()方法，让用户可以自己设置要获取的数据源。
package com.zyh.service.serviceimp;

import com.zyh.dao.UserMapper;
import com.zyh.dao.daoimp.UserMapperImp;
import com.zyh.service.UserService;

public class UserServiceImp implements UserService {
    private UserMapper userMapper = new UserMapperImp();
    public void getUser() {
        userMapper.getUser();
    }
    //用户自己设置要获取的数据来源
    public void setUserMapper(UserMapper userMapper) {
        this.userMapper = userMapper;
    }
}
  • 用户只需要在测试中直接调用这个setUserMapper的方法就可以了。

测试：

package com.zyh.dao;

import com.zyh.dao.daoimp.UserMapperMysqlImp;
import com.zyh.service.UserService;
import com.zyh.service.serviceimp.UserServiceImp;
import org.junit.Test;

public class TestIOC {
    @Test
    public void test1(){
        UserMapperMysqlImp userMapperMysqlImp = new UserMapperMysqlImp();
        UserService userService = new UserServiceImp();
        //用户自己修改参数改变数据的来源，利用set实现了注入
        ((UserServiceImp) userService).setUserMapper(userMapperMysqlImp);
        userService.getUser();
    }
}

执行结果：
在这里插入图片描述

这两种做法的区别：

  • 在最开始，程序中的是主动创建的，控制权在程序人员的手里。
  • 使用set注入后，程序不在是主动的了，而是变成被动的接收。
什么是IOC？

IOC—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。 如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来分析一下：

  • 谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。
  • 控制反转是一种通过描述（XML配置或注解）并通过第三方去生产或获取对象的方式。在Spring中实现控制反转的是IOC容器，它的实现方法是依赖注入（Dependency Injection）DI。
三、Spring hello,world程序

Spring 中的配置：

通过Maven仓库导入Spring依赖和单元测试依赖

        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>

实体类Hello程序，记得编写set方法。

package com.zyh.pojo;

public class Hello {
    private String name;
    public Hello(){
       Stste.out.println("无参构造器");
    }
    public void setName(String name) {
       this.name = name;
    }
    public void show(){
        System.out.println("hello,"+name);
    }
}

编写Spring配置文件：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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

编写applicationContext.xml配置文件，实现对象注入

    <!--一个bean就是一个对象
    id对应的就是对象的名字
    class就是要注入对象的模板类
    property就是给对象的属性设值-->
    <bean id="hello" class="com.zyh.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>

测试：

package com.zyh.pojo;

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

public class TestHelloSpring {
    @Test
    public void test1(){
        //读取Spring的配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取注入对象
        Hello hello = (Hello) context.getBean("hello");
        hello.show();
    }
}

执行结果：
在这里插入图片描述

四、IOC创建对象的方式
1、IOC默认使用无参构造器进行创建对象。
2、IOC使用有参构造创建对象

实体类：

package com.zyh.pojo;

public class User {
    private String name;

    public User() {
        System.out.println("User的无参构造");
    }

    public User(String name) {
        System.out.println("User有参构造");
        this.name = name;
    }

    public void setName(String name) {
        System.out.println("使用了User setName()");
        this.name = name;
    }

    public String getName() {
        return name;
    }
    public void show(){
        System.out.println("name=" + name);
    }
}
方式一：通过下标constructor-arg index=" "给参数赋值
        <bean id="user" class="com.zyh.pojo.User">
            <!--index是参数的下标，0为第一个参数，value为给参数的赋值-->
            <constructor-arg index="0" value="hang"/>
        </bean>
方式二：通过参数类型type给参数赋值，但这种方式存在缺陷，若两个参数类型一样，就不能这样用了。
       <bean id="user" class="com.zyh.pojo.User">
            <constructor-arg type="java.lang.String" value="JoJo"/>
       </bean>
方式三：使用参数名给参数赋值
        <bean id="user" class="com.zyh.pojo.User">
            <constructor-arg name="name" value="Fofo"/>
        </bean>

总结：在Spring的.xml配置文件被加载的时候，bean中的对象就已经被创建好了。

3、bean 中的 ref
若 bean 中的对象初始化创建对象的话，参数为基本类型，可以像下面这个例子一样出给参数赋值。
    <bean id="Mysql" class="com.zyh.mapper.MysqlUserMapperImp">
          <property name="" value=""/>
    </bean>
但如果参数不是基本类型，就要通过ref来给参数赋值。
     <bean id="SqlServer" class="com.zyh.mapper.SqlServerUserMapperImp"/>
     <bean id="UserService" class="com.zyh.service.UserServiceImp">
         <property name="userMapper" ref="SqlServer"/>
     </bean>
五、Spring 配置

Spring的配置参数只有四个，在上面我们已经见过了bean，其他参数为：alias、description、import。
在这里插入图片描述

1、bean
<bean id="" class="" name=""/>
id 是 bean 的唯一表示符，class是这个对象模板的全限定名，name可以给这个对象取一个别名。
2、alias 给bean中的对象取别名
<alias name="Mysql" alias="gg" />
name的值为bean的id值，alias的值就是别名。
3、import
这个参数一般用于团队开发，可以导入多个配置文件，并合并到一起。

在总的配置文件中导入.xml配置

    <import resource="beans1.xml"/>
    <import resource="beans2.xml"/>
六、依赖注入（DI）
依赖：所有的bean对象的创建都依赖于Spring容器
注入：bean对象中的所有属性，都通过Spring容器来注入

依赖注入的方式：

  • 方式一：构造器注入

    Spring 中默认使用无参构造创建对象并注入。

  • 方式二：通过 set 方法注入

测试环境搭建：

两个实体类

//地址
package com.zyh.pojo;

public class Address {
    private String  address;

    public String getAddress() {
        return this.address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

//学生
package com.zyh.pojo;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;

public class Student {
    private String name;
    private Address address;
    private String[] book;
    private List<String> hobby;
    private Map<String,String> card;
    private Properties info;
    private String scholarship;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBook() {
        return book;
    }

    public void setBook(String[] book) {
        this.book = book;
    }

    public List<String> getHobby() {
        return hobby;
    }

    public void setHobby(List<String> hobby) {
        this.hobby = hobby;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    public String getScholarship() {
        return scholarship;
    }

    public void setScholarship(String scholarship) {
        this.scholarship = scholarship;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", book=" + Arrays.toString(book) +
                ", hobby=" + hobby +
                ", card=" + card +
                ", info=" + info +
                ", scholarship='" + scholarship + '\'' +
                '}';
    }
}

在resources目录下创建Spring配置文件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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

</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">

    <beans>
        <bean id="address" class="com.zyh.pojo.Address">
            <property name="address" value="xian"/>
         </bean>
        <bean id="student" class="com.zyh.pojo.Student">
            <!--1、普通值value注入-->
            <property name="name" value="zyh"/>
            <!--2、应用值ref注入-->
            <property name="address" ref="address"/>
            <!--3、数组注入-->
            <property name="book">
                <array>
                    <value>斗破苍穹</value>
                    <value>武动乾坤</value>
                    <value>大主宰</value>
                    <value>元尊</value>
                </array>
            </property>
            <!--4、List-->
            <property name="hobby">
                <list>
                    <value>打篮球</value>
                    <value>跑步</value>
                    <value>俯卧撑</value>
                </list>
            </property>
            <!--5、Map-->
            <property name="card">
                <map>
                    <entry key="xiaohu" value="001"/>
                    <entry key="xiaoming" value="002"/>
                    <entry key="xiaojian" value="003"/>
                </map>
            </property>
            <!--6、Properties-->
            <property name="info">
                <props>
                    <prop key="account">20200226</prop>
                    <prop key="petName">jojo</prop>
                </props>
            </property>
            <!--7、Null-->
            <property name="scholarShip">
                <null/>
            </property>
        </bean>
    </beans>
</beans>

测试：

import com.zyh.pojo.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
//        System.out.println(student.getName());
//        System.out.println(student.getAddress());
        System.out.println(student);
    }
}

执行结果：
在这里插入图片描述

  • 方式三：拓展方式注入：p命名空间和c命名空间注入

需要导入的xml约束：

       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"

实体类：User

package com.zyh.pojo;

public class User {
    private int age;
    private String name;

    public User() {

    }
    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

注入：

    <beans>
        <!--p命名空间注入-->
        <bean id="user" class="com.zyh.pojo.User" p:name="zyh" p:age="20"/>
        <!--c命名空间注入-->
        <bean id="user2" class="com.zyh.pojo.User" c:name="hang" c:age="18"/>
    </beans>

测试：

import com.zyh.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest2 {
    @Test
    public void test1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = context.getBean("user", User.class);
        System.out.println(user);
        User user2 = context.getBean("user2", User.class);
        System.out.println(user2);
    }
}

执行结果：
在这里插入图片描述

七、bean 的作用域

在这里插入图片描述

  • 单例模式：singleton（默认）
<bean id="user2" class="com.zyh.pojo.User" c:name="hang" c:age="18" scope="singleton"/>
  • 原型模式：prototype
<bean id="user2" class="com.zyh.pojo.User" c:name="hang" c:age="18" scope="prototype"/>
八、bean 的自动装配
  • 自动装配是Spring满足bean依赖一种方式！
  • Spring会在上下文中自动寻找，并自动给bean装配属性！

测试环境：

实体类：

//猫
package com.zyh.pojo;

public class Cat {
    public void shut(){
        System.out.println("miao ...");
    }
}

//狗
package com.zyh.pojo;

public class Dog {
    public void shut(){
        System.out.println("wang ...");
    }
}
//人 
package com.zyh.pojo;

public class Person {
    private String name;
    private Dog dog;
    private Cat cat;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", dog=" + dog +
                ", cat=" + cat +
                '}';
    }
}
1、byName 自动装配
通过 byName 自动装配的时候，要保证装配的bean id和自动注入的set方法的值一致
    <bean id="dog" class="com.zyh.pojo.Dog"/>
    <bean id="cat" class="com.zyh.pojo.Cat"/>
    <bean id="person" class="com.zyh.pojo.Person" autowire="byName">
        <property name="name" value="hang"/>
    </bean>

测试 ：

import com.zyh.pojo.Person;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = context.getBean("person", Person.class);
        person.getDog().shut();
        person.getCat().shut();
    }
}

执行结果：
在这里插入图片描述

2、 byType 自动装配
通过byType自动装配时，要保证这个被自动注入的bean的class唯一，类型要和被装配的一致。
    <bean id="dog111" class="com.zyh.pojo.Dog"/>
    <bean id="cat111" class="com.zyh.pojo.Cat"/>
    <bean id="person" class="com.zyh.pojo.Person" autowire="byType">
        <property name="name" value="hang"/>
    </bean>
3、使用注解进行自动装配

使用注解进行自动装配需要导入约束和注解支持：

导入约束并开启注解支持

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

        <!--开启注解的支持-->
        <context:annotation-config/>
@Autowired

在实体类中加注解：

    @Autowired
    private Dog dog;
    @Autowired
    private Cat cat;

测试：

import com.zyh.pojo.Person;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = context.getBean("person", Person.class);
        person.getDog().shut();
        person.getCat().shut();
    }
}

执行结果：
在这里插入图片描述

如果 @Autowired 自动装配的环境较为复杂，就配合 @Qualifier(value = "dog2")注解进行选定Bean对象。
    <bean id="dog" class="com.zyh.pojo.Dog"/>
    <bean id="dog3" class="com.zyh.pojo.Dog"/>
    <bean id="dog2" class="com.zyh.pojo.Dog"/>

    @Autowired
    @Qualifier(value = "dog2")
    private Dog dog;
@Resource
    @Resource
    private Dog dog;
    @Resource
    private Cat cat;

如果xml配置中没有默认名的bean对象，就会报错。

<!--    <bean id="dog" class="com.zyh.pojo.Dog"/>-->
    <bean id="dog3" class="com.zyh.pojo.Dog"/>
    <bean id="dog2" class="com.zyh.pojo.Dog"/>
    <bean id="cat" class="com.zyh.pojo.Cat"/>
    <bean id="cat2" class="com.zyh.pojo.Cat"/>
    <bean id="cat3" class="com.zyh.pojo.Cat"/>
    <bean id="person" class="com.zyh.pojo.Person">
    </bean>

这时我们可以在 @Resource 中加一个属性name 让它去找到指定的 Bean 对象自动装配。

    @Resource(name = "dog2")
    private Dog dog;
小结：@Resource和@Autowired 的区别
  • @Autowired 是通过byType的方式实现的，要求这个 bean 对象必须存在
  • @Resource 默认是通过byName的方式实现的，如果找不到这个bean对象，就使用byType。
九、使用注解开发

在 Spring4 之后，使用注解进行开发，就需要导入 aop 的依赖，并且需要保证导入 context 支持。

<?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/>
    <!--开启扫描包-->
    <context:component-scan base-package="com.zyh"/>
</beans>

在 web 开发中，我们会按照MVC三层架构分层dao、service、controller
这几个层的衍生注解：

  • dao ：@Repository
  • service：@Service
  • controller：@Controller
十、使用Java配置Spring
使用Java配置Spring后，我们就不再需要applicationContext.xml配合文件了。

实体类： @Component

package com.zyh.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//这个注解的意思就是这个类被Spring接管了，被注册到容器中
@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }
    @Value("hang")
    public void setName(String name) {
        this.name = name;
    }

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

配置类： @Configuration

package com.zyh.config;

import com.zyh.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

//这个注解意思也是这个类被Spring接管，注册到Spring容器中。
//代表这个类只一个配置类，就像之前之前的applicationContext.xml一样
@Configuration
@ComponentScan("com.zyh.pojo")
public class MyConfig {

    //注册一个Bean，相当于我们之前在applicationContext.xml中写的<bean></bean>一样
    @Bean
    public User getUser(){
        return new User();
    }
}

测试： AnnotationConfigApplicationContext

import com.zyh.config.MyConfig;
import com.zyh.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    @Test
    public void test1(){
        //通过AnnotationConfigApplicationContext去加载容器
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        //配置类中的方法名就相当于bean的id，返回值就相当于bean的class
        User user = context.getBean("getUser", User.class);
        System.out.println(user.getName());
    }
}

执行结果：
在这里插入图片描述
在以后学习SpringBoot的过程中，这种使用Java配置Spring的方式很常见。

spring框架之ioc简介
浔者的博客
10-29 354
spring框架 用途 整合其他框架，让他们协同工作 提供了声明式的事务管理 – 通过配置(xml, 注解)来管理事务 两大核心思想：IOC，AOP 1. IOC简介（控制反转） 在web项目，一个servlet class servlet extends HttpServlet{ init() service() destroy() } 创建不是程序员来管的 --&amp;amp;amp;amp;amp;amp;gt; tomcat容器...
Spring实现一个简单的SpringIOC容器
08-30
Spring的IOC（Inversion of Control，控制反转）容器是其核心...虽然这个简单的实现可能没有Spring框架那样全面和高效，但它可以帮助我们理解Spring IOC容器的工作原理，为进一步学习和研究Spring框架打下坚实的基础。
Spring IOC
weixin_42213903的博客
12-09 426
what is IOC 控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup） Dependency Injection 依赖注入 关于什么是依赖 关于注入和查找以及拖拽...
SpringIoc
m0_49024941的博客
03-10 356
.Spring框架的概念 .Spring中ioc操作 .Spring的工作原理 一.Spring框架的概念 Spring是一个开源容器框架，可以接管web层，业务层，dao层，持久层的组件，并且可以配置各种bean,和维护bean与bean之间的关系。其核心就是控制反转(IOC),和面向切面(AOP),简单的说就是一个分层的轻量级开源框架。 二.Spring中的Ioc IOC：(全称:Inverse Of Control )，控制反转容器主动将资源推送给它所管理的组件，组件所做的是选择一种合理的
Spring中的IOC详解
最新发布
web15285868498的博客
03-22 673
单例Bean和多实例Bean的生命周期主要区别在于实例化和销毁的管理方式，单例Bean在容器启动时创建一个实例，并由容器负责管理其生命周期的完整过程。在Spring框架中，Bean是应用程序的核心组件，它们由Spring容器创建、组装和管理，以帮助开发者实现松耦合、可测试和可维护的代码。IOC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。Bean的自动装配是Spring框架提供的一种便捷的方式，用于自动解析和设置Bean之间的依赖关系，而无需显式配置每一个依赖关系的方式。
Spring —— IoC 简介
m0_51976820的博客
04-11 2043
Spring —— IoC 简介
spring简介[IOC]
qq_40690208的博客
05-14 198
1、spring简介(IOC) Spring框架是一个开放源代码的J2EE应用程序框架，是针对bean的生命周期进行管理的轻量级容器。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Sp
Java-Spring-SpringIoC容器-SpringIoC的学习
10-11
在Java Spring框架中，Spring IoC（Inversion of Control，控制反转）是核心特性之一，它使得应用程序的组件之间的依赖关系不再由代码直接管理，而是交由Spring IoC容器负责。这种设计模式降低了代码间的耦合，提高...
springIoc实现原理
04-20
Spring Ioc（Inversion of Control，控制反转）是Spring框架的核心特性之一，它改变了传统应用程序中对象的创建和管理方式。在传统的软件设计中，对象的创建和依赖关系的维护通常由代码自身来完成，而在Spring Ioc中...
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心所在，本文将从 ...
实验一 Springioc基本操作.docx
03-07
SpringIOC是Spring Framework中的核心组件之一，负责管理应用程序中的对象、依赖关系和生命周期。 在 Spring IOC 中，对象的创建和管理是通过 BeanFactory 或 ApplicationContext 实现的。BeanFactory 是 Spring ...
SpringIOC
涂文远的博客
07-15 158
IOC 控制反转： 对象创建工作交给别人来完成 springIOC 基于XML方式解决程序耦合 setter注入参数 及 构造注入参数 package com.twy.service; public class DbUtil { String driver; String url; String uname; String upwd; public DbUtil(String driver, String url, String uname, String upwd) { s
springIOC
wca1995的博客
04-06 662
IOC:指程序中对象的获取方式发生了反转，从最初的new方式创建，转变为第三方框架创建，注入（DI）,它降低了对象之间的耦合度，是spring框架的基础与核心。IOC为一种控制反转的思想，DI是实现IOC的主要技术途径。DI：依赖注入，将一起工作具有关系的对象，通过构造方法参数或方法参数传入建立关联。DI实现方式：1.构造器注入2.setter注入3.接口注入（不常用）创建应用对象之间协作关系的行...
Spring IoC
qq_33700236的博客
03-29 168
1. Spring概述 Spring 中，它会认为 Java 类都是资源，而资源都 Bean ，容纳这些 Bean 的是 Spring 所提供的 IoC 容器，所以 Spring 种基于 Bean的编程。 2.SpringIoC概述 有如下的例子： 现实中系统的开发者是个团队，团队由许多开发者组成。现在假设你在一个电商网站负责开发工作，你熟悉商品交易流程，但是对财务却不怎么熟悉，而团队中有些成员对于财务处理分熟悉，在交易的过程中，商品交易流程需要调度财务的相关接口，才能得以实现，那么你的期望应该是： 熟
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值