SSM-Spring之SpringIOC入门

最新推荐文章于 2025-06-05 14:36:46 发布

weixin_46390886

最新推荐文章于 2025-06-05 14:36:46 发布

阅读量90

点赞数

文章标签： java

本文链接：https://blog.youkuaiyun.com/weixin_46390886/article/details/109380898

版权

本文介绍了Spring的核心概念，包括IoC和AOP，Spring MVC、持久层与数据访问组件，以及依赖注入的原理和应用。通过实例演示如何配置Spring容器和使用注解进行依赖注入。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spring介绍

Spring是什么？
Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架
》full-stack Service Dao web
》轻量级按需添加模块
》开源可以获取源代码
以 IoC- （Inverse Of Control：反转控制）和 AOP- （Aspect Oriented Programming：面向切面编程）
为内核
有什么特点？
提供了展现层 SpringMVC
持久层 Spring JDBC
还能整合开源世界众多著名的第三方框架和类库
业务层事务管理 AOP
方便解耦，简化开发 IOC
Java源码是经典学习范例
逐渐成为使用最多的 Java EE 企业应用开源框架

Spring架构体系

Test :用于测试使用
Core container：核心容器，就是用于装Java Bean对象
AOP：切面编程
Aspects：提供了与AspectJ的集成
Data access：数据访问。用于访问操作我们的数据库。支持持久层的操作。jdbcTemplate mybatis
Web：用于支持数据展示层，支持http请求
Transactions：用于支持事物处理。用于解决业务层的事物处理问题。编程式事务管理和声明式事务管理

Spring的IOC理论

什么是IOC
控制反转- （Inversion of Control，缩写为IoC）
》把原来new对象的这种方式转换成了,spring通过反射创建对象的方式
》spring创建完的对象放到一个容器中,谁需要就给谁注入进去- （获取对象并赋值给引用）
简单说:把创建对象和管理对象的权利交给spring

环境搭建

创建Project maven
创建模块module maven
配置依赖

<!--spring依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>

代码编写

定义Person类
手动完成创建与赋值
由spring创建与赋值
》创建容器对象

 ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");

》读配置文件
applicationContext.xml

Test01SpringIOC

public class Test01SpringIoc {
 ClassPathXmlApplicationContext context;
    @Before
    public  void init(){
        //创建IOC 容器对象   暂时看出map   并给定配置文件的名称
        context=new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据id调用容器的getBean方法来获取对象
    }

    @Test
public  void test01(){

    Person person1=(Person)context.getBean("person");
    Person person2=context.getBean("person",Person.class);
    System.out.println(person1);
        System.out.println(person2);
}
}

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

    <!--    Spring容器创建一个person对象
               配置类名,用于反向创建对象,并且给一个编号方便查找-->
    <bean id="date01" class="java.util.Date"></bean>
    <bean id="person" class="com.zx.domain.Person" >
     <!--  <property name="id" value="01"></property>  调用的是set方法来赋值-->
        <constructor-arg name="id" value="02"></constructor-arg>
        <constructor-arg name="name" value="02"></constructor-arg>
        <constructor-arg name="age" value="02"></constructor-arg>
        <constructor-arg name="birthday" ref="date01" ></constructor-arg>
    </bean>

    <!--静态工厂-->
    <bean class="com.zx.demo02.PersonFactory"  factory-method="getBean"  id="person2"></bean>

    <!--实例工厂-->
    <bean id="factory02" class="com.zx.demo02.PersonFactory02"></bean>
    <bean factory-bean="factory02" factory-method="getBean" id="person3"></bean>

    <!--生命周期-->
    <bean id="person4"  class="com.zx.domain.Person"  init-method="init" destroy-method="destory" />

    <!--依赖注入-->
    <bean id="person5"  class="com.zx.domain.Person"   >
              <property name="list">
                    <list>
                        <value>rose1</value>
                        <value>rose2</value>
                        <value>rose3</value>
                    </list>
              </property>
    </bean>

   <!-- <bean id="personService" class="com.zx.service.PersonService">
        <property name="personDao"  ref="personDao"></property>
    </bean>
    <bean id="personDao" class="com.zx.Dao.PersonDao"></bean>-->

    <!--开启注解扫描        xmlns:context="http://www.springframework.org/schema/context"-->
    <context:component-scan base-package="com.zx"/>
</beans>

问题与解答

调用getBean方法是否要转型

context.getBean("id值", 类型.class);//无需转型
context.getBean("id值");//需转型

bean标签中的id与class属性
id:bean标签的识别ID，理论上可以随便写,但是一般是类名小写
class:你要上Spring给你创建哪个类的对象,需要写上该类的全路径名
赋值
set方法赋值

 <bean id="person2" class="com.wzx.domain.Person" >
        <property name="id" value="10"/>
        <property name="name" value="rose"/>
        <property name="age" value="20"/>
    </bean>

property标签
一个property标签最后会调一个对应的set方法
name="id"相当于类中的 setId()方法
value="10"相当于 this.id=10;

构造方法赋值

 <bean id="person" class="com.zx.domain.Person" >

       <constructor-arg name="id" value="02"></constructor-arg>
        <constructor-arg name="name" value="02"></constructor-arg>
        <constructor-arg name="age" value="02"></constructor-arg>
        <constructor-arg name="birthday" ref="date01" ></constructor-arg>
    </bean>

constructor-arg标签
构造方法中的参数有几个就必须写几个

特别说明如果参数的类型是参数,则不能使用value,要用ref

 <constructor-arg name="birthday" ref="date01" ></constructor-arg>

工厂模式

通过调用静态方法获取bean对象

public class PersonFactory {
    public static Person getBean(){
        return  new Person();
    }
}

factory-method

<!--    Person person1 = PersonFactory.getBean();-->
    <bean class="com.wzx.demo02.PersonFactory" factory-method="getBean" id="person"/>

实例工厂

通过工厂对象调用成员方法获得bean对象

public class PersonFactory02 {
    public Person getBean() {
        return new Person();
    }
}

factory-bean 创建工厂对象

<!--PersonFactory2 factory2 = new PersonFactory2();-->
 <bean class="com.wzx.demo03.PersonFactory2" id="factory2"/>

factory-method 调用方法获得bean对象

<!--    Person person1 = factory2.getBean();调用工厂的方法-->
  <bean factory-bean="factory2" factory-method="getBean" id="person5"/>

单例和多例

单例

内存中只有一个对象,每次获取到该对象的地址值一样.

问题: 每次获取对象的时候,spring是新创建一个对象还是始终给我们返回同一个对象.
答案: spring默认的情况下创建的对象都是单例的. (每次返回的对象都是同一个)

 private Myclass(){}

    //单例模式  单例模式内存中有且只要一个对象,每次获取该对象的地址值是一样的,通过私有和静态来实现
    private  static  Myclass myClass;
    public static Myclass getInstance(){
       if(myClass==null){
         myClass=  new Myclass();
       }
        return  myClass;
    }

  <bean id="person" class="com.wzx.domain.Person" scope="singleton"/>

多例

内存中的每个对象都是一个新的对象,他们的地址值都不同

private  static  Myclass myClass;
public static Myclass getInstance2(){

        return  new Myclass();
    }

<bean id="person" class="com.wzx.domain.Person" scope="prototype"/>

总结

        scope="singleton" 单例(默认值)
        scope="prototype" 多例
        scope="request" 创建的对象放到request域中
        scope="session" 创建对象放到session对象

spring依赖注入DI

什么是依赖注入

依赖注入又叫DI (dependency injection)
含义:就是给对象的属性设置值.

set方法赋值

让spring调set方法，前提条件类中必须有set方法

简单类型

简单的是基本类型与字符串
property标签
name : 代表的是set方法去掉set,首字母小写
setId-> Id-> id
value: 基本类型或字符串类型的值,具体给属性设置用的
ref (引用) : 引用对象的id,作为一个对象类型注入

  <property name="id" value="10"/>

复杂类型

复杂类型如:Aarry 数组 List 集合 Map集合 Set集合 Properties集合等

 <property name="list">
            <list>
                <value >rose1</value>
                <value >rose2</value>
                <value >rose3</value>
            </list>
            </property>
            <property name="map">
            <map>
               <entry key="10010" value="rose1"/>
               <entry key="10086" value="rose2"/>
               <entry key="110" value="rose3"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="10010">rose1</prop>
                <prop key="10086">rose2</prop>
                <prop key="110">rose3</prop>
            </props>
        </property>

Dao依赖注入

在PersonService类中生成PersonDao类的set方法,给PersonDao类赋值,解决PersonDao为空的问题

 <bean id="personService" class="com.wzx.service.PersonService">
            <property name="personDao" ref="personDao"/>
    </bean>

PersonService

public class PersonService {
    /*PersonDao personDao=new PersonDao();*/
    private    PersonDao personDao;

//使用set方法给PersonDao类赋值
    public void setPersonDao(PersonDao personDao) {
        this.personDao = personDao;
    }

    public boolean login(Person person){
       Person person1=personDao.find(person);
       if(person1==null){
           return  false;
       }
       else {
           return  true;
       }
    }
}

PersonDao

public class PersonDao {

    public Person find(Person person) {
        if("jackma".equalsIgnoreCase(person.getName())&&"123456".equals(person.getPassword())){
            return  person;
        }else {
            return  null;
        }
    }
}

测试

  @Test
    public  void test07(){
        //Dao依赖注入
     /*   PersonService personService=new PersonService();*/
        PersonService personService=context.getBean("personService",PersonService.class);
        Person person=new Person();
        person.setName("jackma");
        person.setPassword("123456");
      boolean flag=personService.login(person);
        System.out.println(flag+"test07");

    }

applicationContext.xml

 <bean id="personService" class="com.wzx.service.PersonService">
            <property name="personDao" ref="personDao"/>
    </bean>
    <bean id="personDao" class="com.wzx.dao.PersonDao">
    </bean>

注解注入

注解配置

更加简单的赋值方式,不用使用bean标签，使用context:component-scan标签

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


    <!--
        使用注解方式进行创建对象
        1.开启注解扫描

        含义:开启注解扫描,指定了 base-package 扫描指定的包,扫描包与子包中所有的类
        查看类上是否有指定的注解, 如果类上有指定的注解,那么就创建给类对象,
        放到spring容器中
    -->
    <context:compon

只有标记有注解的类，才会被创建对象且添加到ioc容器中
四个注解,注解相当于bean标签,用来创建对象


@Conmponent   //其他层
@Repository   //Dao层
@Service     //Service
@Controller("xxx")   //Controller层

public class MyClass{
}

注入

   4种注入方式 (4种赋值方式)
@Autowired
@Qualifier(“bean的id”)  //新版的不支持
@Value("#{bean的id}")
@Resource(name=“bean的id值”)

@Service
public class PersonService {
   //private PersonDao personDao = new PersonDao();
    //第一种：@Autowired或者  @Autowired和@Qualifier("bean的id")搭配
    //第二种：@Value("#{bean的id}")
    //第三种：@Resource(name="bean的id值")
    @Autowired
    PersonDao personDao ;
 }