Java框架之Spring基础篇

最新推荐文章于 2024-04-22 12:13:05 发布

By丶小辉

最新推荐文章于 2024-04-22 12:13:05 发布

阅读量226

点赞数 1

分类专栏： Spring全家桶

本文链接：https://blog.csdn.net/hehui1998/article/details/115033339

版权

Spring全家桶专栏收录该内容

2 篇文章 0 订阅

订阅专栏

前言

本章是复习Java，仅供参考

一、Spring概括

spring是一个开源框架。
spring是为了简化企业开发而生的，使得开发变得更加优雅和简洁。
spring是一个IOC和AOP的容器框架。

二、Spring IOC容器控制反转

IOC是一个容器，（控制什么）是来控制在实现过程中所需要的对象以及依赖对象。
什么是反转：在没有IOC容器之前我们都是在对象中主动去创建依赖对象，这是正转。而有了IOC容器后依赖的对象直接由IOC容器创建并注入到对象中，则我们由主动创建变成了被动接受，这就是反转
哪些方面被反转：依赖的对象
DI介绍：很多人把IOC和DI说成一个东西，笼统来说的话是没有问题的，但是本质上还是有所区别的,希望大家能够严谨一点，IOC和DI是从不同的角度描述的同一件事，IOC是从容器的角度描述，而DI是从应用程序的角度来描述，也可以这样说，IOC是设计思想，而DI是具体的实现方式
eg：早上买菜时，我们需要提着篮子去超市进行购买青菜和大米，这是由我们主动做的事情，当有一个便捷服务站后，只需要我们把菜篮子放在家门口并写上所需要的食物后，就会有人把食物放在篮子里（DI），然后我们只需要拿到食物就行了，这就是我们被动接受，不需要去超市进行购买。

三、Spring框架的版本包

https://repo.spring.io/release/org/springframework/spring/

四、Spring IOC的基本使用

现在的企业开发环境中使用更多的是maven的方式，无须自己处理jar之间的依赖关系，也无须提前下载jar包，只需要配置相关的pom即可，因此推荐大家使用maven的方式来搭建Spring项目。

一、搭建spring项目需要注意的点：

1、一定要将配置文件添加到类路径中，使用idea创建项目的时候要放在resource目录下
2、导包：导入这五个包即可
commons-logging-1.2.jar
spring-beans-5.2.3.RELEASE.jar
spring-context-5.2.3.RELEASE.jar
spring-core-5.2.3.RELEASE.jar
spring-expression-5.2.3.RELEASE.jar
细节点：**
- ApplicationContext就是IOC容器的接口，可以通过此对象获取容器中创建的对象
- 对象在Spring容器创建完成的时候就已经创建完成，不是需要用的时候才创建
- 对象在IOC容器中存储的时候都是单例的，如果需要多例需要修改属性
- 创建对象给属性赋值的时候是通过setter方法实现的
- 对象的属性是由setter/getter方法决定的，而不是定义的成员属性

二、spring对象的获取及属性赋值方式

1、通过bean的id来获取IOC容器中的对象

2、通过bean的类型获取对象

		Person person = (Person) context.getBean("person");
		Person person = context.getBean("person", Person.class);

3、通过构造器给bean对象赋值

		<!--给普通类添加构造方法-->
	  	 <bean id="person" class="com.bean.Person">
        	<property name="id" value="001"></property>
        	<property name="name" value="张三"></property>
        	<property name="age" value="20"></property>
    	</bean>
    	<!--在使用构造器赋值的时候可以省略name属性，但是此时就要求必须严格按照构造器参数的顺序来填写了-->
    	<bean id="person" class="com.bean.Person">
        	<constructor-arg value="001"></constructor-arg>
        	<constructor-arg value="张三"></constructor-arg>
        	<constructor-arg value="20"></constructor-arg>
    	</bean>
    	还有几种方式，这里就不列举了，可以查资料进行了解

4、为复杂类型进行赋值操作

 	<bean id="person2" class="com.bean.Person">
        <property name="id" value="002"></property>
        <property name="name" value="李四"></property>
        <property name="age" value="22"></property>
        <property name="gender" value="男"></property>
	    <!--给数组赋值  第一种-->
        <!-- <property name="hobbies" value="1,2,3"></property>-->
        <!--给数组赋值  第二种-->
        <property name="hobbies">
            <array>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </array>
        </property>
        <!--给引用类型赋值,可以使用ref进行赋值-->
        <property name="student" ref="stu"></property>
        <!--给集合对象进行赋值-->
        <property name="arrayList">
            <list>
                <bean class="com.bean.Student">
                    <property name="stuClass" value="四年级"></property>
                    <property name="stuName" value="诸葛亮"></property>
                </bean>
                <bean class="com.bean.Student">
                    <property name="stuClass" value="五年级"></property>
                    <property name="stuName" value="张爱芳"></property>
                </bean>
                <ref bean="stu"></ref>
            </list>
        </property>
        <property name="set">
            <set>
                <value>1</value>
                <value>2</value>
                <value>3</value>
                <value>2</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="a" value="aaa"></entry>
                <entry key="stu" value-ref="stu"></entry>
                <entry key="grade">
                    <bean class="com.bean.Grade">
                        <property name="id" value="002"></property>
                        <property name="intStu" value="30"></property>
                        <property name="stuPerson" value="张三"></property>
                    </bean>
                </entry>
                <entry>
                    <key>
                        <value>hh</value>
                    </key>
                    <value>1231231</value>
                </entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="aaa">aaa</prop>
                <prop key="bbb">bbb</prop>
            </props>
        </property>
    </bean>

5、继承关系bean的配置

<!--bean之间的继承关系-->
    <!--可以使用abstract标签定义抽象bean，无法进行实例化-->
    <bean id="person" class="com.bean.Person" abstract="true">
        <property name="id" value="001"></property>
        <property name="name" value="张三"></property>
        <property name="age" value="20"></property>
        <property name="gender" value="男"></property>
    </bean>
    <!--parent:指定bean的配置信息继承于哪个bean，value(person)指向父类-->
    <bean id="son" class="com.bean.Person" parent="person">
        <property name="name" value="李四"></property>
    </bean>

6、bean的作用域控制，是否是单例

bean的作用域：singleton、prototype、request、session
- 默认情况下是单例的
- prototype：多实例的
容器启动的时候不会创建多实例bean，只有在获取对象的时候才会创建该对象
- 每次创建都是一个新的对象
- singleton：默认的单例对象
- 在容器启动完成之前就已经创建好对象，获取的所有对象都是同一个

    <bean id="person4" class="com.mashibing.bean.Person" scope="prototype"></bean>

7、bean对象创建的依赖关系

bean对象在创建的时候是按照bean在配置文件的顺序决定的，也可以使用depend-on标签来决定顺序

	<bean id="person" class="com.bean.Person" depends-on="stu"></bean>
   	<bean id="stu" class="com.bean.Student"></bean>
   	<bean id="grade" class="com.bean.Grade"></bean>

8、bean的作用域控制，是否是单例: bean的作用域

singleton、prototype、request、session默认情况下是单例的
通过scope属性可以指定当前bean的作用域
- singleton：单例模式，从IOC容器中获取的都是同一个对象，默认的作用域
- prototype：多例模式，从IOC容器中获取的对象每次都是新的创建

   <bean id="person2" class="com.bean.Person" scope="singleton"></bean>
   <bean id="person2" class="com.bean.Person" scope="prototype"></bean>

9、利用工厂模式创建bean对象

java文件：
public class PersonStaticFactory {
    public static Person getStaticFactory(String name){
        Person person = new Person();
        person.setId(111);
        person.setName(name);
        person.setAge(11);
        return  person;
    }
}
public class personInstanceFactory {
    public Person getInstance(String name){
        Person person = new Person();
        person.setId(222);
        person.setName(name);
        person.setAge(22);
        return  person;
    }
}

xml文件：
	<!--利用工厂方式创建bean-->
    <!--静态工厂：类名.静态方法()-->
    <bean id="person" class="com.factory.PersonStaticFactory" factory-method="getStaticFactory">
        <constructor-arg value="张三"></constructor-arg>
    </bean>

10、继承FactoryBean来创建对象

FactoryBean是Spring规定的一个接口，当前接口的实现类，Spring都会将其作为一个工厂，但是在ioc容器启动的时候不会创建实例，只有在使用的时候才会创建对象

	public class MyFactoy implements FactoryBean<Person> {
    /**
     * @功能描述:返回获取的bean
     * @Param 
     * @return 
     */
    @Override
    public Person getObject() throws Exception {
        Person person = new Person();
        person.setId(33);
        person.setName("王五");
        return person;
    }
    /**
     * @功能描述:获取返回bean的类型
     * @Param 
     * @return 
     */
    @Override
    public Class<?> getObjectType() {
        return null;
    }
    /**
     * @功能描述:判断当前bean是否是单例的
     * @Param 
     * @return 
     */
    @Override
    public boolean isSingleton() {
        return false;
    }
}

	<bean id="myFactoryBean" class="com.factory.MyFactoy"></bean>

11、bean对象的初始化和销毁方法

Spring容器在创建对象的时候可以指定具体的初始化和销毁方法
- init-method:在对象创建完成之后会调用初始化方法
- destroy-method：在容器关闭的时候会调用销毁方法
初始化和销毁的方法跟scope属性也是相关联的
- 如果是singleton的话，初始化和销毁方法都存在
- 如果是prototype的话，初始化会被调用，而销毁方法不会调用

    public void init(){
        //编写N行逻辑代码完成初始化功能
        System.out.println("对象初始化完成");
    }
    public void destory(){
        System.out.println("对象被销毁");
    }

    <bean id="person" class="com.bean.Person" init-method="init" destroy-method="destory" scope="singleton"></bean>

SpringBean的生命周期参考链接： Spring Bean生命周期详解.
SpringBean的生命周期参考图:

12、配置bean对象初始化方法的前后处理方法

spring中包含一个BeanPostProcessor的接口，可以在bean的初始化方法的前后调用该方法，如果配置了初始化方法的前置和后置处理器，无论是否包含初始化方法，都会进行调用

package com.mashibing.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * 在初始化方法调用之前执行
     * @param bean  初始化的bean对象
     * @param beanName  xml配置文件中的bean的id属性
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization:"+beanName+"调用初始化前置方法");
        return bean;
    }

    /**
     * 在初始化方法调用之后执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization:"+beanName+"调用初始化后缀方法");
        return bean;
    }
}

<bean id="myBeanPostProcessor" class="com.mashibing.bean.MyBeanPostProcessor"></bean>

五、spring创建第三方bean对象

在Spring中，很多对象都是单实例的，在日常的开发中，我们经常需要使用某些外部的单实例对象，例如数据库连接池，下面我们来讲解下如何在spring中创建第三方bean实例。

1、导入数据库连接池的pom文件

     <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
     <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>druid</artifactId>
         <version>1.2.5</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
     <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.49</version>
     </dependency>

2、编写配置文件

   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
       <property name="username" value="root"></property>
       <property name="password" value="root"></property>
       <property name="url" value="jdbc:mysql://localhost:3306/dbutil"></property>
       <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
   </bean>

3、编写测试文件

      DruidDataSource dataSource = context.getBean("dataSource", DruidDataSource.class);
      System.out.println(dataSource);
      System.out.println(dataSource.getConnection());

4、spring引用外部配置文件

在配置文件编写属性的时候需要注意，
spring容器在进行启动的时候，会读取当前系统的某些环境变量的配置，
当前系统的用户名是用username来表示的，所以最好的方式是添加前缀来做区分
dbconfig.properties：

	jdbc.driverClassName= com.mysql.jdbc.Driver
	jdbc.url=jdbc:mysql://localhost:3306/dbutil?useSSL=false&autoReconnect=true
	jdbc.username=root
	jdbc.password=root

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
">
<beans>
    <!--当需要引入外部的配置文件的时候，需要导入一些context的命名空间-->
    <context:property-placeholder location="classpath:dbconfig.properties"></context:property-placeholder>
    <bean id="dataSource2" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="driverClassName" value="${jdbc.driverClassName}"></property>
    </bean>
</beans>

5、spring基于xml文件的自动装配

在spring中，可以使用自动装配的功能，spring会把某些bean注入到另外bean中可以使用autowire属性来实现自动装配，有以下几种情况
- default/no：不自动装配
- byname：按照名字进行装配，以属性名作为id去容器中查找组件，进行赋值，如果找不到则装配null
- byType：按照bean进行装配，以属性的类型作为查找依据去容器中找到该组件，
  如果有多个bean对象，那么会报异常，如果找不到bean对象则装配null
- constructor：按照构造器进行装配，先按照有参构造器参数的类型进行装配，没有就直接装配null；如果按照类型找到了多个，那么就使用参数名作为id继续匹配，找到就装配，找不到就装配null

By丶小辉

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java框架之Spring基础篇

前言本章是复习Java，仅供参考一、Spring概括spring是一个开源框架。spring是为了简化企业开发而生的，使得开发变得更加优雅和简洁。spring是一个IOC和AOP的容器框架。二、IOC容器控制反转1、IOC是一个容器，（控制什么）是来控制在实现过程中所需要的对象以及依赖对象。2、什么是反转：在没有IOC容器之前我们都是在对象中主动去创建依赖对象，这是正转。而有了IOC容器后依赖的对象直接由IOC容器创建并注入到对象中，则我们由主动创建变成了被动接受，这就是反转3、哪些方
复制链接

扫一扫