Spring学习——快速上手Spring

字数统计: 2.9k字   |   阅读时长≈ 12分

HelloSpring

导入jar包

注意：Spring需要导入Commons-logging进行日志记录，我们利用maven，它会自动进行依赖下载。

1
2
3
4
5
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

编写代码

  1. 编写一个Hello实体类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class Hello {
       private String name;

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

       public void show(){
           System.out.println("Hello,"+ name );
      }
    }

  2. 编写我们的Spring配置文件，这里我们命名为applicationContext.xml

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    <?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就是java对象 , 由Spring创建和管理-->
       <bean id="hello" class="com.kuang.pojo.Hello">
           <property name="name" value="Spring"/>
       </bean>

    </beans>

  3. 进行测试

1
2
3
4
5
6
7
8
@Test
public void test(){
   //解析beans.xml文件 , 生成管理相应的Bean对象
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   //getBean : 参数即为spring配置文件中bean的id .
   Hello hello = (Hello) context.getBean("hello");
   hello.show();
}

思考

  • Hello 对象是谁创建的 ? hello 对象是由Spring创建的 ？
  • Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的 ？

这个过程叫控制反转

  • 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
  • 反转 : 程序本身不创建对象 , 而变成被动的接收对象

可以通过newClassPathXmlApplicationContext去浏览一下底层源码

修改案例一

我们在案例一中配置新的配置文件，添加配置文件applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?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="MysqlImpl" class="com.kuang.dao.impl.UserDaoMySqlImpl"/>
   <bean id="OracleImpl" class="com.kuang.dao.impl.UserDaoOracleImpl"/>

   <bean id="ServiceImpl" class="com.kuang.service.impl.UserServiceImpl">
       <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写-->
       <!--引用另外一个bean , 不是用value 而是用 ref-->
       <property name="userDao" ref="OracleImpl"/>
   </bean>

</beans>

测试

1
2
3
4
5
6
@Test
public void test2(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("ServiceImpl");
   serviceImpl.getUser();
}

OK , 到了现在 , 我们彻底不用再程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改 , 所谓的IoC，一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

IOC创建对象的方式

通过无参构造方式创建

  1. User.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class User {

       private String name;

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

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

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

    }

  2. applicationContext.xml

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

       <bean id="user" class="com.kuang.pojo.User">
           <property name="name" value="kuangshen"/>
       </bean>

    </beans>

  3. 测试类

    1
    2
    3
    4
    5
    6
    7
    8
    @Test
    public void test(){
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       //在执行getBean的时候, user已经创建好了 , 通过无参构造
       User user = (User) context.getBean("user");
       //调用对象的方法 .
       user.show();
    }

    结果可以发下，在调用show方法之前，User对象已经通过无参构造初始化了

通过有参构造方式创建

  1. User.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class UserT {

       private String name;

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

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

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

    }

  2. applicationContext.xml三种编写方式

    1
    2
    3
    4
    5
    <!-- 第一种根据index参数下标设置 -->
    <bean id="userT" class="com.kuang.pojo.UserT">
       <!-- index指构造方法 , 下标从0开始 -->
       <constructor-arg index="0" value="kuangshen2"/>
    </bean>
    1
    2
    3
    4
    5
    <!-- 第二种根据参数名字设置 -->
    <bean id="userT" class="com.kuang.pojo.UserT">
       <!-- name指参数名 -->
       <constructor-arg name="name" value="kuangshen2"/>
    </bean>
    1
    2
    3
    4
    <!-- 第三种根据参数类型设置 -->
       <bean id="userT" class="com.kuang.pojo.UserT">
          <constructor-arg type="java.lang.String" value="kuangshen2"/>
       </bean>

  3. 测试

    1
    2
    3
    4
    5
    6
    @Test
    public void testT(){
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       UserT user = (UserT) context.getBean("userT");
       user.show();
    }

    ​ 结论：在配置文件加载的时候。其中管理的对象都已经初始化了！

通过工厂方式创建

工厂静态方法实例化

工厂的静态方法返回Bean实例

1
2
3
4
5
public class StaticFactoryBean { 
       public static UserDao createUserDao(){
             return new UserDaoImpl();
       }
}
1
<bean id="userDao" class="com.itheima.factory.StaticFactoryBean"   factory-method="createUserDao" />

工厂实例方法

实例化 工厂的非静态方法返回Bean实例

1
2
3
4
5
public class DynamicFactoryBean { 
    public UserDao createUserDao(){ 
        return new UserDaoImpl();
     }
 }
1
2
<bean id="factoryBean" class="com.itheima.factory.DynamicFactoryBean"/> 
<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>

Spring配置

别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

1
2
<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

Bean的配置

Bean的标签的基本配置

作用

  1. 用于配置对象由Spring来创建
  2. 默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功

基本属性

id：Bean实例在Spring容器中的唯一标识
class：Bean的全限定名称

Bean标签范围配置

scope：指对象的作用范围，取值如下：

范围 说明
singleton 默认值，单例的
prototype 多例的
request WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
session WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global session WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session

官方截图

几种作用域中，request、session作用域仅在基于web的应用中使用（不必关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境。

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

1
<bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

测试

1
2
3
4
5
6
7
@Test
public void test03(){
     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
     User user = (User) context.getBean("user");
     User user2 = (User) context.getBean("user");
     System.out.println(user==user2);
}

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

1
2
3
<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
  或者
<bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

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

1
<bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>

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

Session
当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

1
<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

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

singleton和prototype对比

1）当scope的取值为singleton时
Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
Bean的生命周期：
对象创建：当应用加载，创建容器时，对象就被创建了
对象运行：只要容器在，对象一直活着
对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2）当scope的取值为prototype时
Bean的实例化个数：多个
Bean的实例化时机：当调用getBean()方法时实例化Bean
Bean生命周期：
对象创建：当使用对象时，创建新的对象实例
对象运行：只要对象在使用中，就一直活着
对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

Bean生命周期配置

init-method：指定类中的初始化方法名称
destroy-method：指定类中销毁方法名称

实例代码

1
2
3
4
5
6
7
8
9
10
11
12
<!--bean就是java对象,由Spring创建和管理-->
<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符，如果配置id,又配置了name,那么name是别名
   
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

   class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

import

团队的合作通过import来实现

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

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

建立此博客主要用途：
分享知识、学习笔记、
技术探讨、好的文章收藏整理

在本博客中如果涉及到版权问题
请联系QQ:1583881877

如果对文章中有更好的看法，
请在留言区留下您宝贵的意见呦！！