SpringBoot微服务框架简单学习

1、Spring boot 简介

1.spring Boot是什么？

• Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。

2.spring Boot能做什么？

• spirng Boot是对spring的一个封装，所以spring能做的他都能做

3.springBoot理念：

• 习惯优于配置，基于我们的习惯，他给我们做了很多默认配置

4.核心功能：

• 1.独立运行的Spring项目：他可以以jar包的形式独立运行
• 2.内嵌Servlet容器：这样就无须以war包形式运行
• 3.提供Starter简化Maven配置：相当于基于项目版本，再将我们需要的架包整合
• 4.自动配置Spring：我们就不需要写Spring和SpringMVC的配置

5.spring配置方式

• 1.xml配置：spring 1.x时代
• 2.注解配置：spring 2.x时代。最终选择应用的基本配置（如数据库配置）用xml配置，业务配置用注解配置
• 3.Java配置：spring 3.x到现在，spring提供了Java配置的能力，spring 4.x和spring boot都推荐使用Java配置
  • @Configuration注解 用在类上， 声明当前类是一个配置类，相当于xml文件。
  • @Bean注解 用在方法上，声明当前方法的返回值为一个bean

1.1 hello world

在介绍spring boot 之前，我们完成一个hello world，然后再来介绍

第一步：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.hqyj</groupId>
  <artifactId>1809_springboot</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  
  <!-- 父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
    </parent>

   <dependencies>
   
   <!-- spring boot 核心依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    

<!-- 模板依赖，前端依赖 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

</dependencies>
  <build>
    <plugins>
		<plugin>
			<!-- spring打成war包所需要的插件 -->
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				
			</plugin>
		</plugins>
	</build>
  
  
  
</project>

第二步：创建一个MyMain.java类，代码如下：

//@SpringBootApplication springboot核心注解   搭建了IOC和AOP  
@SpringBootApplication
//@Configuration指的是当前类是一个配置类
@Configuration
//扫描
@ComponentScan(basePackages="com.hqyj.springboot")
public class MyMain {
    public static void main(String[] args) {
        SpringApplication.run(MyMain.class, args);
    }

}

第三步：创建控制器Hello.java 代码如下：

@Controller
public class Hello {
    
    @RequestMapping("hello")
    @ResponseBody
    public String test(){
        return "hello world！";
    }
}

第四步：运行程序，在MyMain.java中，运行RunAs---->java application。

在浏览器输入地址：http://localhost:8080/hello 访问

---

1.2 spring boot简介

1.介绍

微服务架构

Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。

该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

2.spring boot优缺点

优点：

去除了大量的xml配置文件
简化复杂的依赖管理
快速启动容器
极大的提高了开发、部署效率。

缺点：

在改造以往的ssm和ssh项目起来很麻烦
侧重于做微服务，在做大型项目没有ssm和ssh项目好
全部采用注解配置，对底层实现难以理解

1.3入口类和@SpringBootApplication

Spring Boot的项目一般都会有*Application的入口类，入口类中会有main方法，这是一个标准的Java应用程序的入口方法。

1、@SpringBootApplication：Spring Boot项目的核心注解，
主要目的是开启自动配置。

2、@Configuration：这是一个配置Spring的配置类；

1.4 spring boot依赖说明

这是spring boot 核心依赖配置

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
    </parent>
   <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
</dependency>

这是配置访问html页面所依赖的包

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

spring boot编译插件，才可以使用Java -jar命令来启动jar包，并且有了这个插件，
打的包里面才会有maven依赖的jar包和spring boot的启动类，所以打的jar包也就比较大，
而且MANIFEST.MF文件里面也会有启动类的信息。但是如果不加这个插件，则打的包里面就只有class文件，

<build>
    <plugins>
		<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

---

2、如何访问前端页面

Spingboot官方建议不用jsp作为前端页面，采用的是模板页面或者用html来写，实现前后端分离。

在src/main/resources下面定义文件夹templates，在其下面写一个login.html.如图

注意： templates 是文件名不能更改，这是
Spring boot默认的前端页面访问路径

当然你也可以在templates下面创建自定义的文件夹，如图:

下面我们来看下控制层代码，控制层的写法和一起spring mvc写法一样，如果有上一级文件夹，就把文件夹名加上

---

3、配置静态资源访问

要访问js,css.图片等等这些资源，springboot默认的路径是static,如图：

在页面引入的写法，如图：

---

4 application.properties文件介绍

这个文件是springboot的全局配置文件

需要注意的是这个文件名是固定，不能更改,所以不要写错文件名，不然，你想要的需求实现不了的哦，比如tomcat的端口号更改等等

下面一些常用的配置，如下：

#修改内置tomcat的访问端口
server.port=8080
#修改访问路径
server.servlet-path=*.do
#配置日志文件路径
logging.file=D:/mylog/log.log
#配置日志文件级别
logging.level.org.springframework.web=DEBUG
#这是是设置spring mvc编码过滤器的设置，默认是UTF-8。
spring.http.encoding.charset=UTF-8

4.1 读取全局属性配置文件的值

我们在全局属性配置文件里任意设置一个键值对的值：author=wj，然后我们入口类把它读取出来，入口类代码如图下

@SpringBootApplication
//配置扫描
@ComponentScan(basePackages = "com")
//引入数据源类
@Import(MyDataSource.class)
@Controller
public class MyMain {
	@Value("${author}")
	private String author;

    @RequestMapping("/")
    @ResponseBody
    public String wel(){
        return "你好："+author;
    }
    public static void main(String[] args) {
        SpringApplication.run(MyMain.class, args);
    }

}

4.2 读取自定义properties文件

我们还可以自定义propoteis文件的值，然后读取它，操作如下

定义一个jdbc.properties文件，内容如下

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
username=root
password=1234

修改入口类：如下

@SpringBootApplication
//配置扫描
@ComponentScan(basePackages = "com")
//引入数据源类
@Import(MyDataSource.class)
@PropertySource(value={"classpath:jdbc.properties"})
@Controller
public class MyMain {

    @Value("${url}")
    private String url;

    @Value("${driver}")
    private String driver;

    @Value("${username}")
    private String username;

    @Value("${password}")
    private String password;

	
    @RequestMapping("/")
    @ResponseBody
    public String wel(){
    	String info = "数据库驱动:"+driver
    				 +"数据库地址:"+url
    				 +"用户名:"+username
    				 +"密码:"+password;
        return info;
    }
    public static void main(String[] args) {
        SpringApplication.run(MyMain.class, args);
    }

}

运行下看看吧

---

5、springboot整合mybatis

第一步：导入依赖：如下

<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.2.2</version>
		</dependency>
			<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.4.1</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.1</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.30</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
		</dependency>

第二步：用generatorConfig.xml文件把pojo类,sql映射文件,dao层接口统统生成，这一点在ssm里讲过
在这里没什么区别。

第三步：把sql映射文件和mybatis.xml放在src/main/resources目录下面，如图

Sql映射文件不说了，就是generatorConfig生成的文件不需要改动,mybaits.xml文件内容如下;

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	
</configuration>

第四步：编写spring boot整合 mybatis的数据配置类，新建一个java类MyDataSource.java,内容如下(就是把以前xml需要引入的bean和需要配置的属性使用Java代码的形式去实现)

package com.hqyj.springboot.cfg;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.tomcat.util.descriptor.web.ResourceBase;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

@Configuration
public class MyBatis {
	   //用来装载mybatis的映射文件
	   private static Resource[] mapperFiles;
	   //用来装载mybatis的主配置文件
	   private static Resource mybatisConfg;

	
	
	/**
	 * 
	 * <p>
	 * 	配置数据源
	 * </p>
	 * @author HC
	 * @Date 2018年12月10日
	 * @return
	 */

	@Bean(name= {"dataSource"})
	public DataSource getDataSource() {
		BasicDataSource df = new BasicDataSource();
		df.setDriverClassName("com.mysql.jdbc.Driver");
		df.setUrl("jdbc:mysql://localhost:3306/1809_email?characterEncoding=utf-8&useSSL=false");
		df.setUsername("root");
		df.setPassword("963521");
		return df;
	}
	
	/**
	 * 
	 * <p>
	 * 	配置SqlSessionFactory
	 * </p>
	 * @author HC
	 * @Date 2018年12月10日
	 * @return
	 */
	@Bean(name= {"sqlSessionFactoryBean"})
	public SqlSessionFactoryBean getSqlSessionFactoryBean(@Qualifier("dataSource") DataSource dataSource) {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		//加载主配置文件
		bean.setConfigLocation(MyBatis.mybatisConfg);
		//加载mybatis映射文件
		bean.setMapperLocations(MyBatis.mapperFiles);
		
		return bean;
		
		
	}
	
	/**
	 * 
	 * <p>
	 * 	配置数据层扫描
	 * </p>
	 * @author HC
	 * @Date 2018年12月10日
	 * @return
	 */
	@Bean
	public MapperScannerConfigurer getMapperScannerConfigurer() {
		MapperScannerConfigurer msc = new MapperScannerConfigurer();
		msc.setBasePackage("com.hqyj.springboot.dao");
		msc.setSqlSessionFactoryBeanName("sqlSessionFactoryBean");
		return msc;
	}
	
	
	
	 /**
     * 	读取mybatis的配置文件
     */
    static {
    	ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    	MyBatis.mapperFiles = new Resource[] { 
        		resolver.getResource("classpath:mapper/userMapper.xml")
        		};
    	//加载mybatis 主配置文件
    	MyBatis.mybatisConfg = resolver.getResource("classpath:mybatis.xml");
    }

}

第五步: 完成一个crud应用，测试下项目是否可行

---

6、整合shiro权限框架

1、引入依赖

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.2.2</version>
</dependency>

2、编写shiro配置类

package com.hqyj.springboot.cfg;

import java.util.LinkedHashMap;

import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.hqyj.springboot.shiro.MyRealm;

@Configuration
public class ShiroConfig {

	/**
	 * 
	 * <p>
	 * 	自定义权限登录器
	 * </p>
	 * @author HC
	 * @Date 2018年12月10日
	 * @return
	 */
	@Bean(value= {"MyRealm"})
	public MyRealm getMyRealm() {
		MyRealm myrealm = new MyRealm();
		return myrealm;
	}
	
	/**
	 * 
	 * <p>
	 * 	配置会话管理器
	 * </p>
	 * @author HC
	 * @Date 2018年12月10日
	 * @param myRealm
	 * @return
	 */
	
	@Bean(value= {"SecurityManager"})
	public DefaultWebSecurityManager getSecurityManager(@Qualifier("MyRealm")MyRealm myRealm) {
		DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
		manager.setRealm(getMyRealm());
		return manager;
	}
	
	
	/**
	 * 
	 * <p>
	 * 	设置权限访问
	 * </p>
	 * @author HC
	 * @Date 2018年12月10日
	 * @param securityManager
	 * @return
	 */
	@Bean(value= {"ShiroFilter"})
	public ShiroFilterFactoryBean getShiroFilter(@Qualifier("SecurityManager")DefaultWebSecurityManager securityManager) {
		ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
		shiroFilter.setSecurityManager(securityManager);
		
		//设置访问认证权限，使用map键值对
		LinkedHashMap<String, String> map = new LinkedHashMap<>();
		map.put("/hello", "anon");
		map.put("/**","authc");
		shiroFilter.setFilterChainDefinitionMap(map);
		return shiroFilter;
	}
	
	/**
	 * 
	 * <p>
	 * 	配置shiro声明周期
	 * </p>
	 * @author HC
	 * @Date 2018年12月10日
	 * @return
	 */
	@Bean(value= {"lifecycleBeanPostProcessor"})
	public LifecycleBeanPostProcessor getLifecycleBean() {
		LifecycleBeanPostProcessor lifecycleBean = new LifecycleBeanPostProcessor();
		return lifecycleBean;
	}
	
	
	 //加入注解的使用，不加入这个注解不生效
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(@Qualifier("SecurityManager")DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
	
	
}

---

7、设置事务管理

在Spring Boot中推荐使用@Transactional注解来申明事务。

首先需要导入依赖：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

当引入jdbc依赖之后，Spring Boot会自动默认分别注入DataSourceTransactionManager或JpaTransactionManager，所以我们不需要任何额外配置就可以用@Transactional注解进行事务的使用。

在Service中添加@Transactional注解：

补充（使用springboot时在HTML页面取值）

1. 要进行动态处理的元素将使用“th:”为前缀

2. 通过“@{}”引用静态Web资源

3. 读取数据支持EL表达式的写法：${}

要使用th:标签，那么就要加上th的命名空间

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">

取出String类型或基本数据类型的值

• 在Controller中装入数据

@RequestMapping("getString")
	//这里的HttpServletRequest request   使用Map也行
public String getString(HttpServletRequest request) {
	request.setAttribute("name", "王二");
	request.setAttribute("age", 31);
	return "data";
}

• 在data.html中取出值,注意：
  • 1. 这组标签是可以随便取名字的
  • 2.就算标签里面原来有值，也会被th标签的值替换掉，所以第三个数据显示的是“王二”，而不是哈哈哈哈

<body>	
	取出session中的字符串：<span th:text="${name}"></span><br />
	取出session中的基本数据类型：<span th:text="${age}"></span><br/>
	能直接取出么：<lzl th:text="${name}">哈哈哈哈哈</lzl>
</body>

取出javabean中的值

• 在Controller中装入数据

@RequestMapping("getJavaBean")
public String getJavaBean(HttpServletRequest request) {
	request.setAttribute("stu", new Stu("大王", 37, "男"));
	return "javaBeanData";
}

• 在javaBeanData.html中取出值

<body>
    取出session中的JavaBean:<span th:text="'姓名：'+${stu.name}"></span><br />
	<span th:text="${stu.age}"></span><br />
	<span th:text="${stu.sex}"></span><br />
	<div th:object="${stu}">
		姓名：<input  type="text" th:value="${stu.name}"/><br />
		年龄：<input type="text" th:value="*{age}" /><br />
		性别：<input type="text" th:value="*{sex}" /><br />
	</div>
</body>

取出List中的值

• 在Controller中装入数据

@RequestMapping("getListString")
public String getListString(HttpServletRequest request){
	List<String> list = new ArrayList<>();
	list.add("大王");
	list.add("小王");
	request.setAttribute("list", list);
	
	List<Integer> list2 = new ArrayList<>();
	list2.add(37);
	list2.add(31);
	request.setAttribute("list2", list2);
	return "listStringData";
}

• 在listStringData.html中取出数据,注意这有个新标签 th:each=“元素：集合”

<body>
    取出requset中的List数据：
	<div th:each="str:${list}">
		<span th:text="${str}"></span><br />
	</div>
	<div th:each="num:${list2}">
		<span th:text="${num}"></span><br />
	</div>
</body>

取出List中的数据

• 在Controller中装入数据

@RequestMapping("getJavaBeanList")
public String getJavaBeanList(HttpServletRequest request){
	List<Stu> list = new ArrayList<>();
	list.add(new Stu("大王", 37, "男"));
	list.add(new Stu("小王", 31, "男"));
	request.setAttribute("list", list);
	return "listJavaBeanData";
}

• 在listJavaBeanData中取出数据,注意这th:if=""标签的使用

<body>
	<div th:if="${list} != null">
		有数据我就我进来了<br>
		<div th:each="stu:${list}">
			<span th:text="${stu.name}"></span><br />
			<span th:text="${stu.age}"></span><br />
			<span th:text="${stu.sex}"></span><br />
		</div>
	</div>
</body>

取出Map<k, v>中的数据

• 在Controller中装入数据

@RequestMapping("getStringMap")
public String getStringMap(HttpServletRequest request){
	Map<String, String> strMap = new HashMap<>();
	strMap.put("name", "大王");
	strMap.put("sex", "男");
	request.setAttribute("strMap", strMap);
	return "getStringMapData";
}

• 在getStringMapData.html中取出数据

<body>
	<div th:each="map:${strMap}">
		<span th:text="${map.key}"></span>:<span th:text="${map.value}"></span><br />
	</div>
</body>

取出Map<k, javabean>中的数据

• 在Controller中装入数据

@RequestMapping("getJavaBeanMap")
public String getJavaBeanMap(HttpServletRequest request) {
	Map<Integer, Stu> stuMap = new HashMap<>();
	stuMap.put(1, new Stu("大王", 37, "男"));
	stuMap.put(2, new Stu("小王", 31, "男"));
	request.setAttribute("stuMap", stuMap);
	return "getJavaBeanMapData";
}

• 在getJavaBeanMapData.html中取出数据

<body>
	<div th:each="map:${stuMap}">
		<span th:text="${map.key}"></span>:<span th:text="'  ' + ${map.value.name} + '  ' + ${map.value.age} + '  ' + ${map.value.sex}"></span>
	</div>
</body>

thymeleaf默认是到requset中取值，那如果值是在session和servletContext中呢，其实取的方式都一样，只不过要在前面加上session.或者application.

将数据装入session有2种方式：

• 1.使用@SeesionAttributes注解

@Controller
@SessionAttributes({"name", "age"})
public class SessionController {
	@RequestMapping("getSessionData1")
	public ModelAndView sessionData1() {
		ModelAndView mView = new ModelAndView();
		mView.addObject("name", "大王");
		mView.addObject("age", 18);
		mView.setViewName("sessionData");
		return mView;
	}
}

• 2.使用session参数

@RequestMapping("getSessionData2")
public String sessionData2(HttpSession session) {
	session.setAttribute("name", "小王");
	session.setAttribute("age", 20);
	return "sessionData";
}

• 3.取出数据

<body>
	session中取出的值：<span th:text="${session.name}"></span><br>
	session中取出的值：<span th:text="${session.age}"></span><br>
	能在默认的request中取到值么？<span th:text="${name}"></span><br>
</body>

方式	区别
注解方式	不写session和写了都能取出值
使用session参数	必须写session.才能取出值

将数据装入servletContext中，获得servletContext对象有2种方式：

• 1.通过request或者session获取

ServletContext servletContext = session.getServletContext();

• 2.通过注解方式获得

@Autowired
private ServletContext servletContext;

servletContext.setAttribute("sex", "男");

servletContext中取出的值:<span th:text="${application.sex}"></span>

使用Ajax和在jsp中使用Ajax大部分显示一致

• 只不过在JS中取得对象的值应该用[[${表达式}]]来获取

th标签