Spring-IOC

最新推荐文章于 2024-09-08 18:12:58 发布
最新推荐文章于 2024-09-08 18:12:58 发布
阅读量167 收藏
点赞数 2
文章标签： spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54433643/article/details/120382578
版权

Spring

1.简介

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

        也就是从实际开发中抽取出开的框架，找到可以通用的步骤，把特定的部分空出开，留给开发者自主操作，这样也就提高了开发效率。但是Spring的优点不仅限于此，Spring独立于各种应用服务器，基于Spring开发的应用，可以做到Write Once，Run Anywhere。还有Spring的IOC容器，提高了组件之间的解耦。AOP支持允许将一些通用的任务、事务、日志等进行集中式管理，提高了代码的复用性。ORM和DAO与第三方持久层框架进行良好整合，简化了底层数据库的访问。Spring还有高度的开放性，因为这后面也就产生了各种各样的Spring升级版。

Spring框架图：

spring-overview​

ORM：（Object Relation Mapping）对象关系映射，是一种程序设计技术，用于实现面向对象语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在里使用的“虚拟对象数据库”。如今已有很多免费和付费的ORM产品，而有些程序员更倾向于创建自己的ORM工具。

OXM：Object/XML Mapping 就是Java对象和XML文档之间的映射。

ORM：Object Relation Mapping 是一种程序设计技术，用于面向对象编程语言里不同类型系统的数据之间的转换。

JMS：Java Message Service 是一个Java平台中关于消息中间件的API，用于两个应用程序之间，或分布式系统中发送消息，进行异步通讯。JMS是与具体平台无关的API，绝大多数的中间件都是支持的。

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。

总括：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

Spring-IOC

1.控制反转

        控制反转也就是控制权的交换，在普通的程序中，我们是直接在对象的内部通过new来创建对象，程序主动去创建对象。在IOC容器中，对象的创建和调用都是由Spring管理，IOC容器来创建和控制对象，不再使用new。这样想就是IOC控制住了对象。

传统程序中：传统程序，就是我们自己在对象中主动去获取依赖的对象。

 有了IOC之后：IOC帮我们找到并且创建项目所依赖的对象。

2.IOC和DI

控制反转和依赖注入，其实是同一个概念的不同角度的描述，控制反转的描述。依赖注入，是组件之间的依赖关系，是由容器在运行时决定的，这样说也可以理解成，DI包含于IOC，容器动态的将依赖关系注入到组件中，DI也可以认为是实现IOC的一种方式。

3.IOC的目的

目的就是降低组件之间的耦合度：

在这里插入图片描述

 4.IOC的实现方式

控制反转的底层实现原理：工厂设计模式，Java反射，XML解析。

        （1）BeanFactory：IOC容器的基本接口，不供给开发者使用，加载文件时不会创建对象，在获取时才会进行创建。

        （2）ApplicationContext：Beanfactory的子接口，提供更多更强大的功能，加载配置文件时，就会把在配置文件中的对象进行创建。

在这里插入图片描述

4.简单体现

（1）导jar包（必须要有commons-logging）

创建User实体

public class User {
    private String name;
    
    public User(){
        System.out.println("...创建成功...");
    }

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

    public String getName() {
        return name;
    }

    public void add(){
        System.out.println("...添加成功...name:"+name);
    }
}

配置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="entity.User">
        <property name="name" value="张三"/>
    </bean>
</beans>

Test

    @Test
    public void Test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        System.out.println(user);
        user.add();
        User user1 = context.getBean("user",User.class);
        System.out.println(user1);
        user1.add();
    }

这里的user和user1，均是由Spring容器创建的，对应的name属性也是Spring设置的。

控制反转：这里的对象是由Spring创建，而不是和传统程序一样，由程序本身new出一个对象，对象的创建的权利交给了Spring，程序变成了对象的接受者。

5.IOC创建对象

        5.有参构造方法

//无参-见上

User_1

public class User_1 {
    private String name;

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

    public String getName() {
        return name;
    }

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

    public void addUser(){
        System.out.println("...添加成功...name:"+name);
    }
}

XML

<!--    Test2-->
<!--    <bean id="user_1" class="com.spring.demos.entity.User_1">-->
<!--&lt;!&ndash;        参数名注入&ndash;&gt;-->
<!--        <constructor-arg name="name" value="李四"/>-->
<!--    </bean>-->
    <bean id="user_1" class="com.spring.demos.entity.User_1">
<!--        参数类型注入-->
        <constructor-arg type="java.lang.String" value="李五"/>
    </bean>

Test

@Test
    public void Test2(){
        User_1 user_1 = (User_1) context.getBean("user_1");
        user_1.addUser();
    }

输出：

6.Spring配置

6.1 设置别名

用alias标签为bean设置别名，一个bean可以有多个别名

（也可以认为是，一个类在不同场景下应用时，不同的名字）

    <alias name="user_1" alias="userNew"/>

6.2 Bean的配置

<!--    bean就相当于由Spring控制的是Java对象-->
<!--    id 是bean的标识符，是惟一的，如果没有设置id，会默认使用name，如果id和name同时存在，name就相当于是别名的作用-->
<!--    name里可以设置多个别名，可以用空格，都好，分号隔开-->
<!--    如果id，name均没有配置，可以使用getBean(XX.class)来获取对象-->
<!--    class中是全类名-->
    <bean id="user" name="user2 user3,user4;user5" class="com.spring.demos.entity.User">
        <property name="name" value="张三"/>
    </bean>

6.3 获取其他人的XML

import获取

<import resource="{path}/beans.xml"/>

7.依赖注入（DI）

所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。

Dependency Injection 分为两种，设值注入，构造注入。

7.1构造注入：

见前构造方法那

7.2Set注入

被注入的属性必须要有set方法，并且set的方法名要由set+属性首字母大写，如果属性是boolean类型，要有is方法。

Student类：

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;

    public Properties getInfo() {
        return info;
    }

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

    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[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

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

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

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }
    public void show(){
        System.out.println("name="+ name
                + ",address="+ address.getAddress()
                + ",books="
        );
        for (String book:books){
            System.out.print("<<"+book+">>\t");
        }
        System.out.println("\n爱好:"+hobbys);

        System.out.println("card:"+card);

        System.out.println("games:"+games);

        System.out.println("wife:"+wife);

        System.out.println("信息："+info);
    }
}

XML配置：

<bean id="adr" class="com.spring.demos.entity.Address">
        <property name="address" value="SD"/>
</bean>

<bean id="student" class="com.spring.demos.entity.Student">
        <property name="name" value="张六"/>
        <property name="address" ref="adr"/>
<!--        数组注入-->
        <property name="books">
            <array>
                <value>12345</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>红楼梦</value>
                <value>三国演义</value>
            </array>
        </property>

<!--        Map注入-->
        <property name="card">
            <map>
                <entry key="schoolCard" value="2020000001"/>
                <entry key="IDCard" value="20210909"/>
            </map>
        </property>

<!--        Set注入-->
        <property name="games">
            <set>
                <value>PUMG</value>
                <value>LoL</value>
            </set>
        </property>
<!--        注入null-->
        <property name="wife"><null/></property>

<!--        List注入-->
        <property name="hobbys">
            <list>
                <value>看电影</value>
                <value>钓鱼</value>
                <value>吃东西</value>
            </list>
        </property>

<!--        Properties注入-->
        <property name="info">
            <props>
                <prop key="学号">20210909</prop>
                <prop key="性别">男</prop>
                <prop key="别名">小六</prop>
            </props>
        </property>
    </bean>

Test：

7.3 P注入 和C注入

这里的p、c注入都需要在头文件里添加约束：

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


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

这里的p就是Properties，直接注入属性：

 <bean id="user" name="user2 user3,user4;user5" class="com.spring.demos.entity.User" p:name="zhangzhang"/>

c就是Constructor，构造器注入：

 <bean id="user" name="user2 user3,user4;user5" class="com.spring.demos.entity.User" c:name="zhangzhang"/>

8.Bean的作用域

8.1Single（单例模式）

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域，就是默认是单例模式。

public void Test(){
        User user = (User) context.getBean("user");
        System.out.println(user);
        user.add();
        User user1 = context.getBean("user",User.class);
        System.out.println(user1);
        user1.add();
        System.out.println(user==user1);
    }

8.2 Prototype（原型模式）

当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。

XML配置

<bean id="user_1" class="com.spring.demos.entity.User_1" scope="prototype">
<!--        参数名注入-->
        <constructor-arg name="name" value="李四"/>
    </bean>

 Test：

public void Test2(){
        User_1 user_1 = (User_1) context.getBean("user_1");
        System.out.println(user_1);
        User_1 user_11 = (User_1) context.getBean("user_1");
        System.out.println(user_11);
        System.out.println(user_11==user_1);
        user_1.addUser();
    }

输出：

 8.3 Request

当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。

<bean id="user_1" class="com.spring.demos.entity.User_1" scope="request">
<!--        参数名注入-->
        <constructor-arg name="name" value="李四"/>
    </bean>

针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

8.4Session

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

<bean id="user_1" class="com.spring.demos.entity.User_1" scope="session">
<!--        参数名注入-->
        <constructor-arg name="name" value="李四"/>
    </bean>

9.Bean的生命周期

Bean实例生命周期的执行过程如下：

  • Spring对bean进行实例化，默认bean是单例；

  • Spring对bean进行依赖注入；

  • 如果bean实现了BeanNameAware接口，spring将bean的id传给setBeanName()方法；

  • 如果bean实现了BeanFactoryAware接口，spring将调用setBeanFactory方法，将BeanFactory实例传进来；

  • 如果bean实现了ApplicationContextAware接口，它的setApplicationContext()方法将被调用，将应用上下文的引用传入到bean中；

  • 如果bean实现了BeanPostProcessor接口，它的postProcessBeforeInitialization方法将被调用；

  • 如果bean实现了InitializingBean接口，spring将调用它的afterPropertiesSet接口方法，类似的如果bean使用了init-method属性声明了初始化方法，该方法也会被调用；

  • 如果bean实现了BeanPostProcessor接口，它的postProcessAfterInitialization接口方法将被调用；

  • 此时bean已经准备就绪，可以被应用程序使用了，他们将一直驻留在应用上下文中，直到该应用上下文被销毁；

  • 若bean实现了DisposableBean接口，spring将调用它的distroy()接口方法。同样的，如果bean使用了destroy-method属性声明了销毁方法，则该方法被调用；

10.Bean的自动装配

自动转配，就是Spring在上下文中查找某个bean依赖的bean

Bean的装配机制有三种：

  1. 在xml中显式配置；
  2. 在java中显式配置；
  3. 隐式的bean发现机制和自动装配。

自动装配时，会扫描组件，自动发现向下文中所创建的Bean，找到之后就是自动注入。

XML配置：

<bean id="UserDao" class="com.spring.demos.dao.UserDaoImp"/>
    <bean id="UserService" class="com.spring.demos.service.UserServiceImp">
<!--    这里是set注入 name中是set方法后面的首字母小写后的-->
<!--    这里是引用的bean里的UserDao，引用用的是ref，而不是value    -->
        <property name="userDao" ref="UserDao"/>
    </bean>
public class UserDaoImp implements UserDao{
    @Override
    public void addUser() {
        System.out.println("...添加成功....");
    }
}


public class UserServiceImp implements UserService{
    private UserDaoImp userDaoImp = new UserDaoImp();
    @Override
    public void setUserDao(UserDaoImp userDaoImp) {
        this.userDaoImp = userDaoImp;
    }

    @Override
    public void getUserDao() {
        userDaoImp.addUser();
    }
}

Test：

  public void Test1(){
        UserServiceImp userServiceImp = (UserServiceImp) context.getBean("UserService");
        userServiceImp.getUserDao();
    }

 10.1byName

autowire byName (按名称自动装配)  由于在手动配置xml过程中，常常发生字母缺漏和大小写等错误。（由方法中的参数名称来查找bean里的对象）

    <bean id="student" class="com.spring.demos.entity.Student" autowire="byName">

按照 Bean 名称自动装配存在错误装配 JavaBean 的可能，如果配置文件中定义了与需要自动装配的 JavaBean 的名称相同而类型不同的 JavaBean ，则会错误的注入不同类型的 JavaBean。

10.2 byType

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。

    <bean id="student" class="com.spring.demos.entity.Student" autowire="byType">

无论是按照 Bean 的类型，还是按照 Bean 的名称，自动装配有时候都会出现无法自动装配的情况。例如在配置文件中再添加一个 User 类的实现对象，byType 自动装配类型会因为无法自动识别装配那一个JavaBean 而抛出 org.springframework.beans.factory.UnsatisfiedDependencyException 异常。要解决此类问题，只能通过混合使用手动装配来指定装配哪个 JavaBean 。

10.3使用注解

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

@Autowired XXX 代替set方法；

@Autowired(required=false) 说明：false，对象可以为null；true，对象必须存对象，不能为null。

@Qualifier不能单独使用。

11.使用注解开发

需要导包；

在这里插入图片描述

 进行约束：

<?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.xsd">

</beans>

8.1.Bean的实现

我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！


1、配置扫描哪些包下的注解

<!--指定注解扫描包-->
<context:component-scan base-package="com.kuang.pojo"/>

2、在指定包下编写类，增加注解

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   public String name = "张张";
}

3、测试

@Test
public void test(){
   ApplicationContext applicationContext =
       new ClassPathXmlApplicationContext("beans.xml");
   User user = (User) applicationContext.getBean("user");
   System.out.println(user.name);
}



8.2.属性注入

使用注解注入属性

1、可以不用提供set方法，直接在直接名上添加@value(“值”)

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   @Value("张张")
   // 相当于配置文件中 <property name="name" value="秦疆"/>
   public String name;
}

2、如果提供了set方法，在set方法上添加@value(“值”);

@Component("user")
public class User {

   public String name;

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



8.3.衍生注解

我们这些注解，就是替代了在配置文件当中配置步骤而已！更加的方便快捷！

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

  • @Controller：controller层
  • @Service：service层
  • @Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了！



8.4.自动装配注解

在Bean的自动装配已经讲过了，可以回顾！



8.5.作用域

@scope

  • singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂 ，所有的对象都会销毁。
  • prototype：多例模式。关闭工厂 ，所有的对象不会销毁。内部的垃圾回收机制会回收
@Controller("user")
@Scope("prototype")
public class User {
   @Value("张张")
   public String name;
}



8.6.小结

XML与注解比较

  • XML可以适用任何场景 ，结构清晰，维护方便
  • 注解不是自己提供的类使用不了，开发简单方便

xml与注解整合开发 ：推荐最佳实践

  • xml管理Bean
  • 注解完成属性注入
  • 使用过程中， 可以不用扫描，扫描是为了类上的注解
<context:annotation-config/>

作用：

  • 进行注解驱动注册，从而使注解生效

  • 用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册

  • 如果不扫描包，就需要手动配置bean

  • 如果不加注解驱动，则注入的值为null！

总结

SpringIOC控制反转，指就是说原先在对象中要使用另一个对象就必须要显式的去创建另一个对象的实例，例如通过构造方法或者是调用工厂方法（工厂方法最终也是需要new，因为这是Java创建对象所必须的）来获得。而Spring提供了IOC容器来帮我们生成所需要的对象。也就是说在我们原先的对象中有用到其他对象的地方Spring会帮我们来注入。不用我们再去考虑这些问题。

DI主要就是配置注入（通过XML文件），另一种就是注解

yf_fer
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
maven-spring-ioc
08-07
**Spring IoC 框架详解** Spring框架是Java开发中的一个核心组件，它提供了许多功能，其中最重要的一项就是Inversion of Control（IoC），也称为Dependency Injection（DI）。IoC容器是Spring的核心，它负责管理...
coco-spring-ioc
04-16
在“coco-spring-ioc-master”中，我们可以找到对应的Bean工厂实现，了解其如何加载配置信息，以及如何根据配置创建Bean。 3. **依赖注入**：是IOC的核心，通过配置文件或注解指定Bean之间的依赖关系。在“coco-...
Spring-IoC（XML配置文件形式）
maohe的博客
10-30 1280
IoC思想：为了解耦，。如果我们直接通过new的方式获得对象，需要清楚所有的底层对象初始化过程进行依赖处理，才能进行逻辑处理，而通过IoC引入的对象（外部提供），我们通过依赖注入(DI)的方式进行依赖处理就行。IoC容器从当IoC思想中的"外部"，用来负责对象的创建、初始化等一系列工作，在IoC容器中的对象统称为bean。：在IoC容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入。
Spring-IoC源码分析
一名蒟蒻的博客
05-25 2329
IoC源码分析 1、IoC定义 将原本在程序中⼿动创建对象的控制权，交由Spring框架来管理。 IoC 容器是 Spring⽤来实现 IoC 的载体， IoC 容器实际上就是个Map（key，value），Map 中存放的是各种对象 将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注⼊。 IoC 容器就像是⼀个⼯⼚⼀样，当我们需要创建⼀个对象的时候，只需要配置好配置⽂件/注解即 可，完全不⽤考虑对象是如何被创建出来的。 IoC 的实现原理就是工厂模式加反射机制 优点： 代
Spring-IoC 篇
小周不想写代码的博客
03-16 2433
在 Spring IoC 容器中，每个被管理的对象都由一个 Bean 定义来描述。Bean 定义包括对象的类型、依赖关系、生命周期等信息。
Spring-IOC的XML配置
打酱油的葫芦娃
06-05 5111
引言 在Springboot编程实践中，我们偏向使用注解的方式进行Bean的注册和依赖注入等，但XML格式的容器信息管理方式仍是Spring提供的最为强大、支持最为全面的方式，本文对Spring-IOC的XML配置进行详细的讲解。 <beans>和<bean> BeanFactory和ApplicationContext的XML配置均采用统一的格式，在Spring2.0之前...
spring--IOC详解
Cqy180的博客
06-16 2094
1.IOC容器 2.基于xml管理bean 3.基于注解管理bean
CGB2110-DAY02-Spring-IOC
qq_16804847的博客
12-22 8671
1. Spring框架学习 1.1 Spring介绍 Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合
面试汇总-Spring-IOC和AOP
热门推荐
weixin_37672801的博客
08-18 1万+
Resource对象与对应ApplicationContext类型如下。
Spring-IOC是什么
jj89929665的博客
05-25 2909
Spring-IOC是Spring框架的核心，是一个容器，它负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。，欢迎大家加入我的开源项目，或者(在我的主页联系我)加入你们的开源项目，点点Github-Stars。
Spring-IOC-DI
Cw_Herry的博客
04-15 1950
当我们需要创建一个非常复杂的对象时，例如MyBatis中的SqlSession对象。我们得到SqlSession对象前需要做一系列的事情的时候，就可以使用Spring的工厂模式来创建。定义想要获取的对象，例JavaBean创建JavaBeanFactoryBean用于获取JavaBean实例，需要实现FactoryBean重写 getObject getObjectType 以及 isSingleton方法，获取对象、获取对象类型、是否为单例创建。
Spring-IOC接口
m0_57410337的博客
03-07 2509
1.IOC思想是基于IOC容器完成的，IOC的底层就是对象工厂 2.Spring里边提供了IOC容器的实现的两种方式 (1) BeanFactroy：IOC容器是Spring内部的使用接口，不提供给开发人员使用 public class DemoTest { //传统写法 @Test public void run(){ Demo demo = new Demo(); demo.hello();
Spring-IOC丐版
02-26
Spring框架是Java开发中不可或缺的一部分，它以其强大的依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IOC）特性而闻名。在这个名为"Spring-IOC丐版"的项目中，我们将深入探讨...
Spring-ioc-jar
07-18
这个jar文件"Spring-ioc-jar"包含了实现Spring IOC功能所需的关键类和接口，是学习和使用Spring IOC技术的基础。 Spring框架的IOC容器是其核心组件，主要由`ApplicationContext`和`BeanFactory`两个接口代表。`...
Spring-IoC-DI-main
02-11
标题“Spring-IoC-DI-main”提示我们讨论的核心是Spring框架中的两个核心特性：控制反转（Inversion of Control, IoC）和依赖注入（Dependency Injection, DI）。这两个概念是Java开发中的重要基石，尤其在构建大型...
spring揭秘19-spring事务01-事务抽象
PacosonSWJTU的博客
09-08 955
1）spring对事务元素进行抽象， 客户端仅按照统一的编程模型管理事务，而不用关心数据访问技术以及具体要访问什么类型的事务资源；此外：spring事务管理与spring提供的数据访问技术（如JdbcTemplate）进行结合；2）spring事务框架设计的基本原则： 让事务管理逻辑与数据访问逻辑解耦；spring揭秘15-spring集成数据访问技术(orm框架)总结事务隔离级别；isolation；事务传播行为；事务超时时间；timeout；是否为只读事务；readOnly；
Spring05——注解开发定义bean、Spring纯注解开发模式
最新发布
后端小白个人学习记录
09-08 576
注解开发定义bean、Spring纯注解开发模式
Java项目: 基于SpringBoot+mysql房产销售系统 (含源码+数据库+开题报告+答辩PPT+毕业论文)
weixin_43860634的博客
09-03 592
Java项目: 基于SpringBoot+mysql房产销售系统 (含源码+数据库+开题报告+答辩PPT+毕业论文)
SpringSecurity原理解析（二）：认证流程
liang8999的博客
09-08 561
attemptAuthentication 方法在子类UsernamePasswordAuthenticationFilter 中实现的。attemptAuthentication方法的作用是获取Authentication对象其实就是对应的认证过程，用该AuthenticationProvider的authenticate函数认证，如果认证成功则整个认证过程结束。AuthenticationManager接口中就定义了一个方法authenticate方法，用于处理认证的请求；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值