第一个基于Spring-Boot框架的项目以及Java8新特新之stream流操作的简单细说

       真是好久没有更博了，更博的初衷就是记录工作和学习中的点滴，长期积累，也算是一种资源财富的投资，想着是心里怪美的，但是真要是坚持下来，确实是一个不小的挑战。

        进入新环境已经半个月了，接触了全新的项目，基于gis系统的研发。一开始真是云里雾里，后来博主那叫一个不放弃啊，每天都在问、都在自己摸索，用了一周的时间熟悉项目的数据架构和组织架构，又用了一周的时间熟悉业务，这个业务的熟悉是最痛苦的，比如：如何用对象去表示一个物体在时空领域内的唯一性？

我用必须是抽象的、不能简短的文字大概解答下上述的问题：

答：万物皆对象，这没毛病吧，放眼整个宇宙，我们分为时间领域和空间领域，合起来就是时空领域，用时空域表示一个对象按说已经很流弊了是不是，但是，这还不是唯一的，所以还需要给对象赋予不同的形态、属性、行为，比如我们拿一个静态的办公电脑PC来说：

PC诞生于公元前XXX年XX分XX秒XX毫秒，位于宇宙界银河系地球村XX国XX省XX市XXXX坐标(x,y,z),当然坐标可能是二维坐标也可能是三维立体坐标，还有可能更为复杂，这些描述对象的信息我们称作一个对象对应的时空域。

PC具有型号，名称、显示屏、机箱，鼠标，键盘等属性，形态呢就是显示屏和机箱是矩形立体的，鼠标是不规则弧面体，键盘是凸起的矩形框，行为呢，一个PC是静态的，因此它的行为是被动的，是外界给的，比如，我打开电脑，此时它就具有了上网，看电影、打游戏的行为

以上感觉没漏什么，但细想一下，确实还可以在加点什么，比如对象之间的关系，鼠标和显示屏是什么关系，这是内部关系，还有电脑在整个时空域中和其他对象的关系，比如电脑在一个办公室，它可能放在一个桌子上，那么桌子也是一个对象，那么电脑和桌子之间就存在一个关系，关系我们可以简单理解为组合关系，那就是电脑和桌子简单的组合成了一个办公环境........

沃吉玛，说不下去了，你可想而知，要想在地理系统上，表示一个对象，是需要多少信息去存储的啊，对了，你还要存储对象的生命周期，像svn版本管理器一样，记录每次对象操作的版本号，有了版本号，也就自然而然有了整个对象的完整生命周期，这就厉害了，放电影不就是这样吗，一个个动作帧处理，可以前进也可以倒退，那就是，不说了，所以说，地理信息系统的应用是很广泛的。

啰嗦了一堆，就是再强调一切皆对象，只要是对象，没有Java搞不定的！

一、Spring-Boot框架的搭建

官方强烈推荐：

选择Maven或Gradle构建Spring-Boot系统。

一如既往，使用Maven

(1)创建Maven Project，打包方式为Jar，其中POM文件结构图如下

（2）POM内容如下

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.appleyk</groupId>
	<artifactId>spring-boot-web</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>Java-Web</name>

	<!-- 继承官网最新父POM【假设当前项目不再继承其他POM】 -->
	<!-- http://projects.spring.io/spring-boot/#quick-start -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.9.RELEASE</version>
	</parent>

	<!-- Starter POMs是可以包含到应用中的一个方便的依赖关系描述符集合 -->
	<!-- 该Starters包含很多你搭建项目， 快速运行所需的依赖， 并提供一致的， 管理的传递依赖集。 -->
	<!-- 大多数的web应用都使用spring-boot-starter-web模块进行快速搭建和运行。 -->
	<!-- spring-boot-starter-web -->
	<!-- 对全栈web开发的支持， 包括Tomcat和 spring-webmvc -->
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!-- 添加热部署 devtools：监听文件变动-->
		<!-- 当Java文件改动时，Spring-boo会快速重新启动 -->
		<!-- 最简单的测试，就是随便找一个文件Ctrl+S一下，就可以看到效果 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<!-- optional=true,依赖不会传递-->
			<!-- 本项目依赖devtools；若依赖本项目的其他项目想要使用devtools，需要重新引入 -->  
			<optional>true</optional>
		</dependency>
		
		<!-- JUnit单元测试 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
		</dependency>
	</dependencies>

	<!-- 使用Java8，嘗試使用新特新【stream和lambda】 -->
	<properties>
		<java.version>1.8</java.version>
	</properties>
	
	<!-- Spring Boot包含一个Maven插件， 它可以将项目打包成一个可执行jar -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

注意其中有一个很有用的功能，就是热部署，稍后做演示

（3）整个项目的目录结构如下

这里我不在做解释，稍后，每个文件都是干嘛的，会在注释里说明。

二、全局run函数入口

Application.java

package com.appleyk;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 
 * 下面是一个典型的结构： 
 
com
+- example
+- myproject
+- Application.java -- 注意这个位置，习惯性的放在项目的一开始，也就是根包的第一层
| +
- domain
| +- Customer.java
| +- CustomerRepository.java
| +
- service
| +- CustomerService.java
| +
- web
+- CustomerController.java 


 * 文件将声明 main 方法， 还有基本的 @Configuration
 * 
 * @author yukun24@126.com
 * @date   2017年12月1日08:46:41
 */

// @Configuration
// @EnableAutoConfiguration
@SpringBootApplication  same as @Configuration @EnableAutoConfiguration @ComponentScan					 
public class Application {
	
	/**
	 * SpringApplication类提供了一种从main()方法启动Spring应用的便捷方式。 在很多情况下， 你只需委托给
	 * SpringApplication.run这个静态方法：
	 * @param args
	 */
	
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}

三、全局属性配置文件

application.properties

#SpringApplication将从以下位置加载application.properties文件， 并把它们添加到Spring Environment中：
#1. 当前目录下的一个/config子目录
#2. 当前目录
#3. 一个classpath下的/config包
#4. classpath根路径（root）
#这个列表是按优先级排序的（列表中位置高的将覆盖位置低的） 。
#注：你可以使用YAML（'.yml'） 文件替代'.properties'

本篇暂未用到任何配置

四、POJO类--搭建基础数据

（1）Person.java【抽象父类】

package com.appleyk.pojo;

/**
 * 每个人都有共有的年龄和性别属性
 * @author yukun24@126.com
 * @date   2017年12月1日-上午9:40:13
 */
public abstract class Person {
    private int    age;//年龄
    private String sex;//性别
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
}

（2）User.java【子类】

package com.appleyk.pojo;

/**
 * 简单用户实体类：JavaBean
 * 继承自抽象类Person,得到父类的年龄和性别属性
 * @author yukun24@126.com
 * @blob   http://blog.csdn.net/appleyk
 * @date   2017年12月1日-上午8:50:05
 */
public class User extends Person {

	private int uID; // 用户ID
	private String uName; // 用户名
	private String uPwd; // 用户密码
	private int uRole; // 用户角色 1：普通用户 2：超级管理员

	public User(int ID, String Name, String Pwd, int Role) {
		this.uID   = ID  ;
		this.uName = Name;
		this.uPwd  = Pwd ;
		this.uRole = Role;
	}

	public int getuID() {
		return uID;
	}

	public void setuID(int uID) {
		this.uID = uID;
	}

	public String getuName() {
		return uName;
	}

	public void setuName(String uName) {
		this.uName = uName;
	}

	public String getuPwd() {
		return uPwd;
	}

	public void setuPwd(String uPwd) {
		this.uPwd = uPwd;
	}

	public int getuRole() {
		return uRole;
	}

	public void setuRole(int uRole) {
		this.uRole = uRole;
	}
	
	//输出【out】对象时，调用对象的toString，打印相关信息
	public String toString(){
		return "ID:"+uID+",Name:"+uName+",Role:"+uRole;
	}
}

五、Service层--简单Hello业务接口的创建和实现

(1)HelloService.java

package com.appleyk.service;

/**
 * 多构建interface，多构建abstract ，降低项目各模块间的耦合度
 */

public interface HelloService {
  String sayHello(String name);
}

(2)HelloServiceImpl.java

package com.appleyk.service.Impl;

import org.springframework.stereotype.Service;

import com.appleyk.service.HelloService;

@Service
public class HelloServiceImpl implements HelloService {

	@Override
	public String sayHello(String name) {
		return "Hello World! come from "+name;
	}

}

六、Controller类--简单Hello控制类的Service调用

HelloController.java

package com.appleyk.controller;

import javax.websocket.server.PathParam;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.appleyk.service.HelloService;

/**
 * Hello控制器--第一个Spring-boot项目的入口点
 * @author yukun24@126.com
 * @blob   http://blog.csdn.net/appleyk
 * @date   2017年12月1日-上午9:18:43
 */
@RestController //same as @Controller + @ResponseBody
@RequestMapping("/rest/v1.0.1/appleyk") //restful风格的api接口
public class HelloController {

	@Autowired
	private HelloService helloService;
	
	@RequestMapping("/hello")
	public String HelloWorld(@PathParam("name") String name){
		return helloService.sayHello(name);
	}
}

七、启动项目

（1）启动

（2）大写的Spring，It's cool !

八、API接口测试【Controller测试】

(1)浏览器测试

(2)API测试工具测试

九、Spring-Boot热部署测试

（1）修改HelloServiceImpl.java内容如下

（2）Ctrl+S，立马见效

A.

B.工具验证一下

十、Java8新特性，stream流的简单操作，很实用

(1)单元测试类

StreamTest.java

package com.appleyk.Java8.feature.test;

import java.io.PrintStream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import org.junit.Test;

import com.appleyk.pojo.User;

public class StreamTest {

	@Test
	public void Test01() throws Exception {

		List<User> users = Arrays.asList(
				new User(5, "appleyk", "123456", 2), 
				new User(1, "kobe"	 , "k521"  , 1),
				new User(3, "James"  , "J521"  , 1), 
				new User(4, "Oven"   , "O521"  , 1), 
				new User(2, "Kuri"   , "kr521" , 1)
				);

		// Java8中提供了Stream流对象对集合的操作，并作出了极大的简化
		
		// 1.流遍历，获取每个user对象的用户名
		PrintStream out = System.out;
		
		users.stream().forEach(user -> {
			String name = user.getuName();
			out.println(name);
		});

		System.out.println("<><<><><<><><><><><><><><><><><>");

		// 2.流遍历，根据uID排序，并打印排序后的用户信息

		users.stream().map(User::toString).sorted().forEach(System.out::println);

		System.out.println("<><<><><><><><><><><><><><><><><>");

		// 3.流遍历，取得用户id，并将取得的id收集【collect】起来，由收集器【Collectors】转化为list集合返回
		List<Integer> uids = users.stream().map(User::getuID).collect(Collectors.toList());
		for (Integer id : uids) {
			System.out.print(id + "\t");
		}
		
		System.out.println("\n<><<><><<><><><><><><><><><><><>");
		
		//4.流遍历筛选，只保存超级管理员的用户信息[role = 2的代表超级管理员，1的是普通用户]
		List<User> managers = users.stream().filter(user->user.getuRole()==2).collect(Collectors.toList());
		System.out.println("超级管理员的个数是："+managers.size());

	}
}

(2)测试结果亮瞎眼

本篇到这算是简单的串了一下整个项目，后续还会持续对Spring-Boot进行探究，总之，使用Spring-Boot框架，你会发现做web项目很轻松，很愉悦，而在项目中结合java8新特性，stream和lambda对数据集进行操作，简直效率到爆表，这一块，我还在充电中，后续会记录。