Spring

原创已于 2022-06-18 13:51:00 修改 · 143 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #java #eureka #intellij-idea #jar

于 2022-06-18 13:36:25 首次发布

intellij-idea 专栏收录该内容

2 篇文章

订阅专栏

本文介绍了如何使用Spring框架，从引入依赖、配置文件创建到BeanFactory和ApplicationContext的区别。展示了创建Dao类并进行测试的过程，详细解释了Bean的作用域以及获取Bean的多种方式。此外，讨论了Spring的IOC控制反转概念，依赖注入的目的和实现方式，并给出了注入对象属性值的实例。最后，提到了注解配置和自动注入在简化代码中的应用。

使用spring可以降低对象与对象之间的耦合

1.如何使用spring

步骤：

1.1引入相关的依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>
    </dependencies>

1.2创建spring的配置文件

<?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容器来创建
        id:bean的唯一标识/class: 类的所有路径                -->
     <bean id="userDao" class="com.yhm.UserDao"></bean>
</beans>

1.3创建一个Dao类

public interface IUserDao {
    public void show();
}
public class UserDao implements IUserDao {

    public void show(){
        System.out.println("==========");
    }
}

1.4写一个测试类，运行一下看是不是正确的

public class Test01 {
    public static void main(String[] args) {
        //识别spring文件
        ApplicationContext app=new ClassPathXmlApplicationContext("application.xml");
        //获取bean对象
        IUserDao userDao = (IUserDao) app.getBean("userDao");
        userDao.show();
    }
}

2.BeanFactory和ApplicationContext的区别

BeanFactory是工厂模式的实现，是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。而ApplicationContext接口是基于BeanFactory之上的，提供了应用程序框架服务，扩展的新功能如下：提供国际化的支持资源访问，如URL和文件事件传递载入多个配置文件等实现类。

·································································································································

· BeanFactory 和 ApplicationContext 的区别：
· BeanFactory 才是 Spring 容器中的顶层接口。
· ApplicationContext 是它的子接口。

· 单例模式下创建对象的时间点不一样：
· ApplicationContext：(饿汉模式)只要一读取配置文件，马上就会创建配置文件中配置的对 · 象。
· BeanFactory：(懒汉模式)什么时候getBean("id")，也就是说当根据id获取对象时，才会创 · 建。

·
· 选择:饿汉式:

3.常见的ApplicationContext接口：

ClassPathXmlApplicationContext：-classpath路径加载xml文件的

FileSystemXmlApplicationContext：基于项目根路径进行加载xml文件的

AnnotationConfigApplicationContext：基于注解的配置。基于类书写的配置。

4获取bean的方式

4.1通过bean.xml文件中bean标签的id的值获取bean(使用默认构造方法)

//根据bean的id获取Bean对象，强制进行转换.
IUserDao iUserDao= (IUserDao) app.getBean("userDao");

4.2通过类型去获取

//通过类型获取bean对象。
IUserDao userDao = app.getBean(IUserDao.class);

4.3通过 id + 类型去获取

IUserDao userDao = app.getBean("userDao02", IUserDao.class);

5.bean对象的作用范围

调整需要配置scope属性，设置单例还是多例（只针对ApplicationContext接口来说，默认是单例的）

单例:无论创建多少次对象他们始终指向同一个实例。

scope：常用的有singleton,prototype

singleton：单例的（默认值）当加载配置文件时，就会创建对象。

prototype：多例的（当getBean时才会创建对象）

request：作用于请求范围---同一个那么使用bean同一个。

session：作用于会话范围---同一个会话

6.为什么要使用spring?

(1)spring搭建工程

(2)spring的IOC控制反转的概念。

(3)beanFactory和ApplicationContext的区别？

(4) Bean的获取方式.

(5)bean的作用范围有: 4个

7.IOC控制反转

依赖注入目的：就是给对象中的属性赋值

IOC控制反转的最终目的就是降低程序的耦合，也就是削减依赖关系。

8.依赖注入的方式：

分为三种类型：

8.1.基本数据类型和String

8.2.其它bean实体对象类型(在配置文件中或者注解配置过的bean)

8.3 复杂类型/集合类型(集合类型只能通过配置文件注入)

9.依赖注入的类型：

9.1基本数据类型

9.2字符串类型

9.3引用类型

9.4集合类型

如何实现注入对象的属性值：

1)创建一个类:---提供set方法

package com.yhm.demo;


public class Student {
     private Integer age;
     private String name;

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

    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

2）配置文件:---在bean标签中<property name="属性名" >

<?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="student01" class="com.yhm.demo.Student">
        <property name="name" value="梁又年"/>
        <property name="age" value="23"/>
    </bean>
</beans>

使用spring注入其他数据类型

1）注入类对象类型

public class Student {
     private Integer age;
     private String name; 

     //添加一个班级对象
     private Clazz clazz;

<?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="student01" class="com.yhm.demo.Student">
        
        <property name="name" value="梁又年"/>
        <property name="age" value="23"/>
        <property name="clazz" ref="clazz02"/>
    </bean>


    <bean id="clazz01" class="com.yhm.demo.Clazz">
          <property name="cid"  value="1"/>
          <property name="cname" value="建筑系一班"/>
    </bean>
    <bean id="clazz02" class="com.yhm.demo.Clazz">
        <property name="cid"  value="2"/>
        <property name="cname" value="服装系一班"/>
    </bean>
</beans>

注入集合可以分为自动注入和手动注入

自动注入：

public class UserController {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void fun(){
        userDao.show();
    }
}

public interface UserDao {

    public void show();
}

public class UserDao01 implements UserDao {
    public void show() {
        System.out.println("userDao01-------------------show方法");
    }
}

public class UserDao02 implements UserDao{
    public void show() {
        System.out.println("userDao02~~~~~~~~~~~~~~~~~~~show方法");
    }
}

使用注解完成IOC和DI功能

1）包扫描配置文件

    <!--包扫描-->
    <context:component-scan base-package="com.yhm.demo03"/>

2）创建controller

@Controller  //表示控制层注解
public class UserController {

    @Autowired
    @Qualifier(value = "userDaoImpl01") //<property name="userDao" ref="userDaoImpl01">
    private UserDao userDao;

    public void fun(){
        userDao.print();
    }
}

3) 创建dao接口和实现类

@Repository
public class UserDaoImpl01 implements UserDao {

    public void print() {
        System.out.println("userDao01~~~~~~~~~~~~~~~~~~~~~~~~~~~~~print方法");
    }
}


@Repository
public class UserDaoImpl02 implements UserDao {

    public void print() {
        System.out.println("userDao02~~~~~~~~~~~~~~~~~~~~~~~~~~~~~print方法");
    }
}

@Controller控制层
@Respository持久化层
@Service 业务层
@Component 最底层的bean注解。
其实他们没有区别: 他们的底层都是用的@Component
实际意思就在于区分层的。