Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

一起学Spring之基础篇

Alan.hsiang 2019-10-09 22:35:00 阅读数:35 评论数:0 点赞数:0 收藏数:0

本文主要讲解Spring的基础环境搭建以及演变由来,仅供学习分享使用,如有不足之处,还请指正。

什么是Spring ?

Spring是一个开源框架,用来处理业务逻辑层和其他层之间的耦合问题。因此Spring将面向接口开发的思想贯穿整个系统应用,且Spring是一个轻量级框架,所以在诞生之初,便风靡Java开发市场,得到了广泛的认可与响应。

Spring基础概念

依赖注入(DI:Dependency Injection)又叫控制反转(IoC:Inversion of Control):将组件对象的控制权从代码本身,转移到外部容器。Spring容器也是一个IoC容器,用来管理所有的Java Bean,主要是通过BeanFactory来进行产生和管理Bean。

Spring框架搭建

1. 建立一个Java Project

Spring框架是即支持Java Project,又支持Dynamic Web Project,如下所示:

2. 导入Spring框架需要的Jar包

Spring框架搭建需要的包共6个,如下所示:

 //日志包
commons-logging-1.1.1.jar
 //spring核心包
spring-aop-4.0.6.RELEASE.jar
 spring-beans-4.0.6.RELEASE.jar
 spring-context-4.0.6.RELEASE.jar
 spring-core-4.0.6.RELEASE.jar
 spring-expression-4.0.6.RELEASE.jar

3. 配置Spring配置文件

对于Java Project来说,applicationContext.xml必须放在src目录,如下所示:

 <?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">
<!-- 此文件默认放置在src目录 -->
<!-- id表示唯一标识,class表示类型,必须为全路径 -->
<bean id="student" class="com.hex.first.Student">
<property name="id" value="1"></property>
<property name="name" value="hex"></property>
<property name="age" value="20"></property>
</bean>
</beans>

对于配置文件中的Student类,定义如下:

 package com.hex.first;

/**
 * 定义一个学生类
  * @author Administrator
  *
 */
public class Student {

/*
 * 学生ID
 */
private int id;

/*
 * 学生姓名
 */
private String name;

/**
 * 年龄
 */
private int age;

public int getId() {
 return id;
  }
 public void setId(int id) {
 this.id = id;
  }
 public String getName() {
 return name;
  }
 public void setName(String name) {
 this.name = name;
  }
 public int getAge() {
 return age;
  }
 public void setAge(int age) {
 this.age = age;
  }

 @Override
 public String toString() {
 // TODO Auto-generated method stub
return "ID="+id+",Name="+name+",Age="+age;
  }
 }
View Code

4. 声明对象

对于常规声明对象和采用Spring获取对象的方式如下:

 //常规New对象方法声明一个对象
Student student=new Student();
 student.setId(1);
 student.setName("hex");
 student.setAge(20);
 System.out.println(student);
 //通过Spring进行注入,Spring上下文对象
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
 //从Spring的IOC容器中获取id为student的bean对象
Student student01=(Student) context.getBean("student");
 System.out.println(student01);
View Code

5. 测试结果

如下所示:

采用Spring方式和传统方式的区别有哪些

传统方式全部采用硬编码的方式,一旦有变动,就需要修改代码,而Spring采用注入的方式,将可变的东西放在配置文件中,便于修改。

1. 首先假设一种场景,学生有一个学习课程的需求

关于课程的接口(ICourse),定义如下:

 /**
 * 定义一个课程接口
  * @author Administrator
  *
 */
public interface ICourse {

/**
 * 学习
 */
void learn();
 }
View Code

分别有两个实现类:JavaCourse和HtmlCourse,代码如下:

 package com.hex.first;

/**
 * 学习Java课程
  * @author Administrator
  *
 */
public class JavaCourse implements ICourse {

 @Override
 public void learn() {
 System.out.println("学习Java课程。。。");

 }

}
View Code

 package com.hex.first;

/**
 * 学习Html课程
  * @author Administrator
  *
 */
public class HtmlCourse implements ICourse {

 @Override
 public void learn() {
 System.out.println("学习Html课程。。。");

 }

}
View Code

如果一个学生要学习这两门课程,有以下三种实现方案:

1. 第一种:原始的多态方法

在Student类中增加两个方法,分别用来学习Java和Html,如下所示:

 /**
 * 学习Java
 */
public void learnJava(){
 ICourse course=new JavaCourse();
  course.learn();
  }

/**
 * 学习Html
 */
public void learnHtml(){
 ICourse course=new HtmlCourse();
  course.learn();
 }
View Code

调用代码如下:

 //第1种,最原始的多态方法
System.out.println("第1种,最原始的多态方法:");
 student.learnJava();
 student.learnHtml();
View Code

备注:此方案导致学生和课程之间形成强耦合关系,假如需要增加一种学习Python语言的课程,需要增加接口的实现类(PythonCourse),修改Student类,增加learnPython方法,改动较大,或者有些学生只学其中一门课程,而另一些学生学两门课程,采用此方案会比较麻烦。

2. 第二种:采用简单工厂方法,将课程的创建抽离出来,由工厂统一管理。

在Student中增加一个学习(learn)方法:

 /**
 * 学习通过参数区分
  * @param name
 */
public void learn(String name){
 ICourse course=CourseFactory.getCourse(name);
  course.learn();
 }
View Code

增加工厂类(CourseFactory)

 package com.hex.first;

/**
 * 课程工厂
  * @author Administrator
  *
 */
public class CourseFactory {

/**
 * 获取课程对象
  * @param name
  * @return
*/
public static ICourse getCourse(String name){
 if(name.equals("java")){
 return new JavaCourse();
 }else{
 return new HtmlCourse();
  }
  }
 }
View Code

然后客户端调用时只需要传字符串就行。如下所示:

 //第2种,简单工厂方法
System.out.println("第2种,简单工厂方法:");
 student.learn("java");
 student.learn("html");
View Code

备注:此方案虽然将对象的创建剥离出来,由工厂进行管理,但是课程的类型还是硬编码的,还是不够完善。

3. 第三种:采用Spring的方式,实现对象的动态注入

在学生类中增加学习方法,参数是ICourse接口:

 /**
 * 传递接口
  * @param course
 */
public void learn(ICourse course){
  course.learn();
  }
 
View Code

在Spring配置文件中,配置要注入的对象:

 <!-- 两个对象,没有属性,不需要赋值 -->
<bean id="java" class="com.hex.first.JavaCourse"></bean>
<bean id="html" class="com.hex.first.HtmlCourse"></bean>

通过Spring来获取对象,实现动态控制:

 //第3种,通过SpringIOC实现
System.out.println("第3种,通过SpringIOC实现:");
 ICourse course=(ICourse)context.getBean("java");
 student.learn(course);
 ICourse course2=(ICourse)context.getBean("html");
 student.learn(course2);
View Code

以上三种方式,均可以实现需求,至于采用哪种方案,可以依据具体实际场景而定。

备注

没有伞的孩子,必须努力奔跑!

版权声明
本文为[Alan.hsiang]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/hsiang/p/11612320.html