Spring 基础入门

Posted 2020-10-24 float123

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring 基础入门相关的知识，希望对你有一定的参考价值。

本文代码部分来自于《spring in action》，本文讲的是使用！！

Spring 是为了解决什么

一个框架的存在是为了解决某个问题的，那么Spring这个框架是为了解决什么问题呢？主要就是解耦，spring主要要把握两方面的知识，

DI(依赖注入 dependency injection) : 解耦，方便测试

AOP（面向切面编程 aspect-oriented programming)

关于 DI Ioc 和 AOP 可以先阅读这篇文章，本文讲的主要是使用。

DI (依赖注入 depency injection)

先看一个例子：

  1 //定义一个勇士类
  2 public class DamselRescuingKnight implements Knight {
  3 
  4 	private RescueDamselQuest quest;
  5 
  6 	//营救任务
  7 	public DamselRescuingKnight() {
  8 		this.quest = new RescueDamselQuest();
  9 	}
 10 
 11 	public void embarkOnQuest() {
 12 		quest.embark();
 13 	}
 14 }

可以看到这里，勇士的 embarkOnQuest ( ) 方法执行的传入的特定的任务，那么当勇士需要执行其他任务的时候就无法进行了，于是Queue 应该做成一个接口.这样的好处是解耦合和方便测试

  1 public class BraveKnight implements Knight {
  2 	private Quest quest;
  3 
  4 	public BraveKnight(Quest quest) {
  5 		this.quest = quest;
  6 	}
  7 
  8 	public void embarkOnQuest() {
  9 		quest.embark();
 10 	}
 11 }

  1 public class SlayDragonQuest implements Quest {
  2 	private PrintStream stream;
  3 
  4 	public SlayDragonQuest(PrintStream stream) {
  5 		this.stream = stream;
  6 	}
  7 
  8 	public void embark() {
  9 		stream.println("Embarking on quest to slay the dragon!");
 10 	}
 11 }

上面使用依赖注入并且在构造器解耦被称为构造器解耦。在spring中如何组装这些组件呢？（将queue配置给knight）

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <beans xmlns="http://www.springframework.org/schema/beans"
  3 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4 	xsi:schemaLocation="http://www.springframework.org/schema/beans
  5 	http://www.springframework.org/schema/beans/spring-beans.xsd">
  6 
  7 	<bean id="knight" class="com.springinaction.knights.BraveKnight">
  8 		<constructor-arg ref="quest" />
  9 	</bean>
 10 
 11 	<bean id="quest" class="com.springinaction.knights.SlayDragonQuest">
 12 		<constructor-arg value="#{T(System).out}" />
 13 	</bean>
 14 </beans>

图一. 依赖注入会将所依赖的关系自动交给目标对象，而不是让对象自己去获取依赖

AOP(面向切面编程)

加入一个勇士需要一个历史记录着纪录它的英雄事迹，那么

  1 public class Recorder {
  2 	private PrintStream stream;
  3 
  4 	public Recorder(PrintStream stream) {
  5 		this.stream = stream;
  6 	}
  7 
  8 	public void singBeforeQuest() {
  9 		stream.println("Fa la la, the knight is so brave!");
 10 	}
 11 
 12 	public void singAfterQuest() {
 13 		stream.println("Tee hee hee, the brave knight " +
 14 		"did embark on a quest!");
 15 	}
 16 }

  1 public class BraveKnight implements Knight {
  2 	private Quest quest;
  3 	private Recorder recorder;
  4 
  5 	public BraveKnight(Quest quest, Recorder recorder) {
  6 		this.quest = quest;
  7 		this.recorder= recorder;
  8 	}
  9 
 10 	public void embarkOnQuest() throws QuestException {
 11 		recorder.singBeforeQuest();
 12 		quest.embark();
 13 		recorder.singAfterQuest();
 14 	}
 15 }

但是这样似乎有点不合常理，当我需要一名勇士时是否每次都要匹配以为记录者？假如记录着可以当我需要的时候出现那么就好了。使用spring的AOP 编程，

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <beans xmlns="http://www.springframework.org/schema/beans"
  3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4        xmlns:aop="http://www.springframework.org/schema/aop"
  5        xsi:schemaLocation="http://www.springframework.org/schema/aop
  6 http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
  7 http://www.springframework.org/schema/beans
  8 http://www.springframework.org/schema/beans/spring-beans.xsd">
  9 
 10     <bean id="knight" class="com.springinaction.knights.BraveKnight">
 11         <constructor-arg ref="quest"/>
 12     </bean>
 13 
 14     <bean id="quest" class="com.springinaction.knights.SlayDragonQuest">
 15         <constructor-arg value="#{T(System).out}"/>
 16     </bean>
 17 
 18     <bean id="minstrel" class="com.springinaction.knights.Recorder">
 19         <constructor-arg value="#{T(System).out}"/>
 20     </bean>
 21 
 22     <aop:config>
 23         <aop:aspect ref="recorder">
 24             <aop:pointcut id="embark"
 25                           expression="execution(* *.embarkOnQuest(..))"/>
 26             <aop:before pointcut-ref="embark"
 27                         method="singBeforeQuest"/>
 28             <aop:after pointcut-ref="embark"
 29                        method="singAfterQuest"/>
 30         </aop:aspect>
 31     </aop:config>
 32 </beans>
 33

Spring 容器

spring容器是使用DI(依赖注入)去管理组成应用的组件，其中包括两大类，

Application Cotext
Bean Factories

Bean Factories 主要是低水准的应用，下面主要介绍application context，它包括

AnnotationConfigApplicationContext ：从一个或多个java形式的class文件中加载一个spring 应用

AnnotationConfigWebApplicationContext ：从一个或多个java形式的class文件中加载一个spring web应用

FileSystemXmlApplication : 加载一个上下文定义（context）从文件路径中的xml文件

XmlWebApplicationConte

ClassPathXmlApplication

AnnotationConfigWebApplicationContext 和 XmlWebApplicationContext 我们使用比较多的

装配组件

三种方式

XML 形式

JavaConfig形式

隐式的bean发现机制和自动装配

三种方式的选择：根据《spring in action》的描述，隐式的bean 发现和自动装配方式强与显式装配，假若不得不显式装配，优先选择类型安全的java编码形式的，最后才是XML形式。

自动配置

Spring从两个角度来实现自动化装配：(一个是生成独立的bean，一个是将他们组装起来)

组件扫描（component scanning）： Spring会自动发现应用上下文中所创建的bean。

自动装配（autowiring）： Spring自动满足bean之间的依赖。

@Component 属性表明这个类是个组件，并且告诉spring 因为为它创建一个been

  1 @Component
  2 public class SgtPeppers implements CompactDisc {
  3 	private String title = "Sgt. Pepper\'s Lonely Hearts Club Band";
  4 	private String artist = "The Beatles";
  5 
  6 	public void play() {
  7 		System.out.println("Playing " + title + " by " + artist);
  8 	}
  9 }

  1 @Configuration
  2 @ComponentScan
  3 public class CDPlayerConfig {
  4 
  5 }

@ComponentScan 表示组件扫描，在这个包下的组件都会被扫描出来并且创建为been，而@Configuration 将会在下面讲到，同时上面也可以通过xml的形式创建

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <beans xmlns="http://www.springframework.org/schema/beans"
  3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4        xmlns:context="http://www.springframework.org/schema/context"
  5        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6             http://www.springframework.org/schema/beans/spring-beans.xsd
  7             http://www.springframework.org/schema/context
  8             http://www.springframework.org/schema/context/spring-context.xsd">
  9     <context:component-scan base-package="soundsystem" />
 10 </beans>

组件被scan 后会生成一个bean ，然后生成一个id,默认为类名，那么下面展示的如何自定义这个id的名字，和如何指定spring在特定的路径下进行扫描

  1   1 //组件命名
  2   2 @Component("lonelyHeartsClub")
  3   3 public class SgtPeppers implements CompactDisc {
  4   4 ...
  5   5 }
  6   6
  7   7 //扫描基本路径，多个基本路径
  8   8 @Configuration
  9   9 @ComponentScan(basePackages= {"soundsystem", "video"})
 10  10 public class CDPlayerConfig {}

扫描基类下的所有类

  1 @Configuration
  2 @ComponentScan(basePackageClasses={CDPlayer.class, DVDPlayer.class})
  3 public class CDPlayerConfig {}

扫描完了，下面展示如何自动装配，使用@Autowired 注解，spring会自动将bean 加载进来，但是当bean 不存在时，spring加载时会抛出错误，为了防止spring直接抛出错误，可以设置 required = false

  1 @Component
  2 public class CDPlayer implements MediaPlayer {
  3     private CompactDisc cd;
  4     @Autowired
  5     public CDPlayer(CompactDisc cd) {
  6         this.cd = cd;
  7     }
  8     public void play() {
  9         cd.play();
 10     }
 11 
 12     @Autowired(required=false)
 13     public OtherCDPlayer(CompactDisc cd) {
 14         this.cd = cd;
 15     }
 16 }

JAVA 编码装配bean

当我们需要使用到第三方库时，我们就不能使用自动装配机制，可以使用XML形式和JavaConfig的形式来进行显式装配，java编码比xml形式的重构更加友好，类型安全，更加强大。

  1 @Configuration
  2 public class CDPlayerConfig {
  3 }

使用@Configuration 注解表明这个类通过javaConfig形式告知spring为它创建一个bean。另外加入我们调用一个方法，而方法返回值是个对象，我们希望这个对象被spring生成一个bean，这又怎么写呢？

  1 @Bean(name="lonelyHeartsClubBand")
  2 public CompactDisc sgtPeppers() {
  3 	return new SgtPeppers();
  4 }

和上面自动扫描一样，我们创建了bean, 是时候把它们装配起来了，假如CDPlayer 这个对象依赖CompactDisc 这个对象，我们需要对它进行注入。上面的代码可以知道sgtPeppers( ) 方法可以获取一个bean对象。

  1 @Bean
  2 public CDPlayer cdPlayer() {
  3 	return new CDPlayer(sgtPeppers());
  4 }

可以看到我们同样调用了sgtPeppers( ) 方法，使用了@Bean注解，这个需要注意的是spring创建的bean都会是单例，什么意思呢？

  1 @Bean
  2 public CDPlayer cdPlayer() {
  3 	return new CDPlayer(sgtPeppers());
  4 }
  5 @Bean
  6 public CDPlayer anotherCDPlayer() {
  7 	return new CDPlayer(sgtPeppers());
  8 }

在sgtPeppers( )方法中即使我们使用new 一个新的对象，调用这两个方法返回的CDPlay( )却是相同的，都是spring 创建的bean对象。我们可以使用一个简单的方式写法。

  1 @Bean
  2 public CDPlayer cdPlayer(CompactDisc compactDisc) {
  3 	return new CDPlayer(compactDisc);
  4 }

XML 方式装配bean

使用XML 形式进行装配bean，

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <beans xmlns="http://www.springframework.org/schema/beans"
  3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5        http://www.springframework.org/schema/beans/spring-beans.xsd
  6        http://www.springframework.org/schema/context">
  7 
  8        <bean id="cdPlay" class="soundsystem.SgtPeppers">
  9 </beans>

初始化bean构造器注入有两种方式

使用<constructor-arg>
使用c-命名空间在Spring 3.0

下面使用的时第一种，ref是传入的引用，是某个bean 的id

  1 <bean id="cdPlayer" class="soundsystem.CDPlayer">
  2 	<constructor-arg ref="compactDisc" />
  3 </bean>

如果存在下面的类

  1 public class BlankDisc implements CompactDisc {
  2         private String title;
  3         private String artist;
  4         public BlankDisc(String title, String artist) {
  5             this.title = title;
  6             this.artist = artist;
  7         }
  8         public void play() {
  9             System.out.println("Playing " + title + " by " + artist);
 10         }
 11     }

那么构造器依赖注入就是

  1 <bean id="compactDisc" class="soundsystem.BlankDisc">
  2     <constructor-arg value="Sgt. Pepper\'s Lonely Hearts Club Band"/>
  3     <constructor-arg value="The Beatles"/>
  4 </bean>
  5 
  6 <!--下面是c-命名空间，下划线后加参数名字-->
  7 <bean id="compactDisc"
  8       class="soundsystem.BlankDisc"
  9       c:_title="Sgt. Pepper\'s Lonely Hearts Club Band"
 10       c:_artist="The Beatles" />
 11 
 12 <!--也可以这样子写-->
 13 <bean id="compactDisc"
 14       class="soundsystem.BlankDisc"
 15       c:_0="Sgt. Pepper\'s Lonely Hearts Club Band"
 16       c:_1="The Beatles" />
 17

如果构造参数中有List，或是set，要是set 的话，只需要改节点为<set>

  1 <bean id="compactDisc" class="soundsystem.BlankDisc">
  2     <constructor-arg value="Sgt. Pepper\'s Lonely Hearts Club Band" />
  3     <constructor-arg value="The Beatles" />
  4     <constructor-arg>
  5         <list>
  6             <value>Sgt. Pepper\'s Lonely Hearts Club Band</value>
  7             <value>With a Little Help from My Friends</value>
  8             <value>Lucy in the Sky with Diamonds</value>
  9             <value>Getting Better</value>
 10             <value>Fixing a Hole</value>
 11             <!-- ...other tracks omitted for brevity... -->
 12         </list>
 13     </constructor-arg>
 14 </bean>

如果使用c命名空间的构造器注入，必须向在开头声明命令空间

  1 
  2 <?xml version="1.0" encoding="UTF-8"?>
  3 <beans xmlns="http://www.springframework.org/schema/beans"
  4        xmlns:c="http://www.springframework.org/schema/c"
  5        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7 http://www.springframework.org/schema/beans/spring-beans.xsd">
  8     ...
  9 </beans>

下面是如何使用

  1 <bean id="cdPlayer" class="soundsystem.CDPlayer"
  2 c:cd-ref="compactDisc" />

假如一个类没有构造方法，需要对属性进行注入

  1 public class BlankDisc implements CompactDisc {
  2     private String title;
  3     private String artist;
  4     private List<String> tracks;
  5     public void setTitle(String title) {
  6         this.title = title;
  7     }
  8     public void setArtist(String artist) {
  9         this.artist = artist;
 10     }
 11 
 12     public void setTracks(List<String> tracks) {
 13         this.tracks = tracks;
 14     }
 15     public void play() {
 16         System.out.println("Playing " + title + " by " + artist);
 17         for (String track : tracks) {
 18             System.out.println("-Track: " + track);
 19         }
 20     }
 21 }

  1 <bean id="compactDisc"
  2       class="soundsystem.BlankDisc">
  3     <property name="title"
  4               value="Sgt. Pepper\'s Lonely Hearts Club Band" />
  5     <property name="artist" value="The Beatles" />
  6     <property name="tracks">
  7         <list>
  8             <value>Sgt. Pepper\'s Lonely Hearts Club Band</value>
  9             <value>With a Little Help from My Friends</value>
 10             <value>Lucy in the Sky with Diamonds</value>
 11             <value>Getting Better</value>
 12             <value>Fixing a Hole</value>
 13             <!-- ...other tracks omitted for brevity... -->
 14         </list>
 15     </property>
 16 </bean>
 17

和c-命名空间相同， p-命名空间用来标识属性注入的，但是需要注意的是p-命名空间不能注入List，只能用spring-util 命名空间对集合进行注入，同样，在使用命令空间时需要在xml开头声明

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

  1 <bean id="compactDisc"
  2       class="soundsystem.BlankDisc"
  3       p:title="Sgt. Pepper\'s Lonely Hearts Club Band"
  4       p:artist="The Beatles"
  5       p:tracks-ref="trackList" />

  1 <util:list id="trackList">
  2     <value>Sgt. Pepper\'s Lonely Hearts Club Band</value>
  3     <value>With a Little Help from My Friends</value>
  4     <value>Lucy in the Sky with Diamonds</value>
  5     <value>Getting Better</value>
  6     <value>Fixing a Hole</value>
  7     <!-- ...other tracks omitted for brevity... -->
  8 </util:list>

即使当显示声明bean时，我们更趋向javaCofig 形式装配，但是有些时候XML 形式的才是最好的选择，spring允许两者混合使用，如下

在javaCofig形式中引入xml配置

加入存在以下图的依赖关系

  1 @Configuration
  2 public class CDConfig {
  3     @Bean
  4     public CompactDisc compactDisc() {
  5         return new SgtPeppers();
  6     }
  7 }
  8 
  9 
玩转Spring——Spring入门基础
 Spring MVC 基础入门二
 JSP基础--JSP入门
 Spring基础 快速入门spring 基础概念
 Spring AOP入门基础-继承装饰者，代理的选择
 SpringBoot 学习笔记01—Spring基础入门