black210
black210

SpringBoot

文章目录

  • 1.了解 SpringBoot
    • 1.1.SpringBoot的起步依赖
    • 1.2.SpringBoot工程热部署
  • 2.SpringBoot原理分析
    • 2.1.分析 spring-boot-starter-parent
    • 2.2 .分析spring-boot-starter-web
    • 2.3.自动配置原理解析
      • 小结
    • 2.4.SpringBoot配置文件
    • 2.5.配置文件与配置类的属性映射方式
      • 使用注解@ConfigurationProperties
      • 使用注解@Value映射
  • 3.一些注解
    • @EnableAutoConfiguration
    • @SpringBootApplication
    • @ConfigurationProperties
    • @EnableConfigurationProperties
  • 4.整合SpringMVC
    • 4.1.添加拦截器
    • 4.2.静态资源访问问题
    • 4.3.配置 Servlet
    • 4.4.整合Filter、Listener
  • 5.整合Mybatis
    • 5.1.通用mapper
    • 5.2.整合事务
    • 5.3.整合Spring Data JPA
  • 6.整合 Junit 等工具
    • 整合 Swagger
  • 7.整合 Thymeleaf
  • 8.整合Redis
  • 9.SpringBoot异步任务
    • 9.1.定时任务
    • 9.2.发邮件
  • 10.安全框架

1.了解 SpringBoot

人们把 Spring Boot称为搭建程序的脚手架。其最主要作用就是帮我们快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让我们关注于业务而非配置。

java一直被人诟病的一点就是臃肿、麻烦。当我们还在辛苦的搭建项目时，可能 Python程序员已经把功能写好了，究其原因主要是两点：

  • 复杂的配置

    项目各种配置其实是开发时的损耗， 因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。

  • 混乱的依赖管理

    项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这也是件棘手的问题。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。

而 SpringBoot 让这一切成为过去！

Spring Boot 主要特征是：

  • 创建独立的 spring 应用程序
  • 直接内嵌 tomcat、jetty和 undertow（不需要打包成war包部署）
  • 提供了固定化的“starter”配置，以简化构建配置
  • 尽可能的自动配置spring和第三方库
  • 提供产品级的功能，如：安全指标、运行状况监测和外部化配置等
  • 绝对不会生成代码，并且不需要XML配置

总之，Spring Boot为所有 Spring 的开发者提供一个开箱即用的、非常快速的、广泛接受的入门体验

更多细节，大家可以到官网查看。

  • 起步依赖

起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

  • 自动配置

Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。

1.1.SpringBoot的起步依赖

SpringBoot要求，项目要继承SpringBoot的起步依赖 spring-boot-starter-parent

<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.0.1.RELEASEversion>
parent>

SpringBoot要集成SpringMVC进行Controller的开发，所以项目要导入web的启动依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
dependencies>

1.2.SpringBoot工程热部署

我们在开发中反复修改类、页面等资源，每次修改后都是需要重新启动才生效，这样每次启动都很麻烦，浪费了大量的时间，我们可以在修改代码后不重启就能生效，在 pom.xml 中添加如下配置就可以实现这样的功能，我们称之为热部署。

使用 spring 提供的 devtools


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-devtoolsartifactId>
dependency>

使用 idea 中 JRebel 插件：

打开 idea 设置，在 pllugins 中搜索，会显示两个JRebel 的插件。我们安装 JRebel for Intellij，选中此插件，对话框右边有个绿色的 install plugin 按钮。点击安装即可。 安装完成之后，需要重启 intellij idea。

2.SpringBoot原理分析

2.1.分析 spring-boot-starter-parent

按住Ctrl点击 pom.xml 中的spring-boot-starter-parent，跳转到了它的pom.xml，配置如下（只摘抄了部分重点配置）：

<parent>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-dependenciesartifactId>
  <version>2.0.1.RELEASEversion>
  <relativePath>../../spring-boot-dependenciesrelativePath>
parent>

按住Ctrl点击pom.xml中的spring-boot-dependencies，跳转到了它的pom.xml，配置如下（只摘抄了部分重点配置）：

<properties>
  	<activemq.version>5.15.3activemq.version>
  	<antlr2.version>2.7.7antlr2.version>
  	<appengine-sdk.version>1.9.63appengine-sdk.version>
  	<artemis.version>2.4.0artemis.version>
  	<aspectj.version>1.8.13aspectj.version>
  	<assertj.version>3.9.1assertj.version>
  	<atomikos.version>4.0.6atomikos.version>
  	<bitronix.version>2.1.4bitronix.version>
  	<build-helper-maven-plugin.version>3.0.0build-helper-maven-plugin.version>
  	<byte-buddy.version>1.7.11byte-buddy.version>
  	... ... ...
properties>
<dependencyManagement>
  	<dependencies>
      	<dependency>
        	<groupId>org.springframework.bootgroupId>
        	<artifactId>spring-bootartifactId>
        	<version>2.0.1.RELEASEversion>
      	dependency>
      	<dependency>
        	<groupId>org.springframework.bootgroupId>
        	<artifactId>spring-boot-testartifactId>
        	<version>2.0.1.RELEASEversion>
      	dependency>
      	... ... ...
	dependencies>
dependencyManagement>
<build>
  	<pluginManagement>
    	<plugins>
      		<plugin>
        		<groupId>org.jetbrains.kotlingroupId>
        		<artifactId>kotlin-maven-pluginartifactId>
        		<version>${kotlin.version}version>
      		plugin>
      		<plugin>
        		<groupId>org.jooqgroupId>
        		<artifactId>jooq-codegen-mavenartifactId>
        		<version>${jooq.version}version>
      		plugin>
      		<plugin>
        		<groupId>org.springframework.bootgroupId>
        		<artifactId>spring-boot-maven-pluginartifactId>
        		<version>2.0.1.RELEASEversion>
      		plugin>
          	... ... ...
    	plugins>
  	pluginManagement>
build>

从上面的spring-boot-starter-dependencies的pom.xml中我们可以发现，一部分坐标的版本、依赖管理、插件管理已经定义好，所以我们的SpringBoot工程继承spring-boot-starter-parent后已经具备版本锁定等配置了。所以起步依赖的作用就是进行依赖的传递。

2.2 .分析spring-boot-starter-web

按住Ctrl点击 pom.xml 中的spring-boot-starter-web，跳转到了它的pom.xml，配置如下（只摘抄了部分重点配置）：


<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  	<modelVersion>4.0.0modelVersion>
  	<parent>
    	<groupId>org.springframework.bootgroupId>
    	<artifactId>spring-boot-startersartifactId>
    	<version>2.0.1.RELEASEversion>
  	parent>
  	<groupId>org.springframework.bootgroupId>
  	<artifactId>spring-boot-starter-webartifactId>
  	<version>2.0.1.RELEASEversion>
  	<name>Spring Boot Web Startername>
  
  	<dependencies>
    	<dependency>
      		<groupId>org.springframework.bootgroupId>
      		<artifactId>spring-boot-starterartifactId>
      		<version>2.0.1.RELEASEversion>
      		<scope>compilescope>
    	dependency>
    	<dependency>
      		<groupId>org.springframework.bootgroupId>
      		<artifactId>spring-boot-starter-jsonartifactId>
      		<version>2.0.1.RELEASEversion>
      		<scope>compilescope>
    	dependency>
    	<dependency>
      		<groupId>org.springframework.bootgroupId>
      		<artifactId>spring-boot-starter-tomcatartifactId>
      		<version>2.0.1.RELEASEversion>
      		<scope>compilescope>
    	dependency>
    	<dependency>
      		<groupId>org.hibernate.validatorgroupId>
      		<artifactId>hibernate-validatorartifactId>
      		<version>6.0.9.Finalversion>
      		<scope>compilescope>
    	dependency>
    	<dependency>
      		<groupId>org.springframeworkgroupId>
      		<artifactId>spring-webartifactId>
      		<version>5.0.5.RELEASEversion>
      		<scope>compilescope>
    	dependency>
    	<dependency>
      		<groupId>org.springframeworkgroupId>
      		<artifactId>spring-webmvcartifactId>
      		<version>5.0.5.RELEASEversion>
      		<scope>compilescope>
    	dependency>
  	dependencies>
project>

从上面的spring-boot-starter-web的 pom.xml 中我们可以发现，spring-boot-starter-web 就是将 web 开发要使用的 spring-web、spring-webmvc 等坐标进行了“打包”，这样我们的工程只要引入 spring-boot-starter-web 起步依赖的坐标就可以进行 web 开发了，同样体现了依赖传递的作用。

2.3.自动配置原理解析

我们知道 @EnableAutoConfiguration会开启 SpringBoot 的自动配置，并且根据你引入的依赖来生效对应的默认配置。

  • 这些默认配置是怎么配置的，在哪里配置的呢？
  • 为何依赖引入就会触发配置呢？
  • 这些默认配置的属性来自哪里呢？

按住 Ctrl 点击查看注解 @EnableAutoConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
	... ... ...
}

其中，@Import(AutoConfigurationImportSelector.class) 导入了AutoConfigurationImportSelector类

按住Ctrl点击查看AutoConfigurationImportSelector源码

public String[] selectImports(AnnotationMetadata annotationMetadata) {
        ... ... ...
        List<String> configurations = getCandidateConfigurations(annotationMetadata,
                                                                   attributes);
        configurations = removeDuplicates(configurations);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return StringUtils.toStringArray(configurations);
}


protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
			AnnotationAttributes attributes) {
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
				getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
		
		return configurations;
}

其中，SpringFactoriesLoader.loadFactoryNames 方法的作用就是从META-INF/spring.factories文件中读取指定类对应的类名称列表

SpringBoot_第1张图片

spring.factories 文件中有关自动配置的配置信息如下：

... ... ...

org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\

... ... ...

上面配置文件存在大量的以Configuration为结尾的类名称，这些类就是存有自动配置信息的类，而SpringApplication 在获取这些类名后再加载

我们以ServletWebServerFactoryAutoConfiguration为例来分析源码：

@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
		ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
		ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
		ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
	... ... ...
}

其中，@EnableConfigurationProperties(ServerProperties.class) 代表加载ServerProperties服务器配置属性类

进入ServerProperties.class源码如下：

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {

	/**
	 * Server HTTP port.
	 */
	private Integer port;

	/**
	 * Network address to which the server should bind.
	 */
	private InetAddress address;
  
  	... ... ...
  
}

其中，prefix = "server"表示SpringBoot配置文件中的前缀，SpringBoot会将配置文件中以server开始的属性映射到该类的字段中。映射关系如下：

SpringBoot_第2张图片

小结

简述一下整个流程：

  • 最主要的注解就是@EnableAutoConfiguration,而这个注解会导入一个EnableAutoConfigurationImportSelector的类
  • 它会利用AutoConfigurationImportSelector给容器中导入一些组件。
  • 扫描所有 jar 包类路径下META-INF/spring.factories,
  • 然后把扫描到的这些文件包装成 Properties 对象。
  • 从 properties 中获取到EnableAutoConfiguration.class类名对应的值，然后把他们添加在容器中。

再简单一点：

  • 整个过程就是将类路径下META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加入到容器中。
  • 每一个这样XXAutoConfiguration类都是容器中的一个组件都加入到容器中，用他们来做自动配置。
  • 如果我们要覆盖这些默认属性，只需要在application.properties中定义与其前缀 prefix 和字段名一致的属性即可。

拓展类

在 Spring 中，有非常多的 xxx Configuration 帮助我们进行拓展配置。

自制 start ：

  • 编写一个 xxxProperties，自动配置类，封装配置文件的内容
  • 定义一个 xxxAutoConfiguration，向容器中自动配置组件
  • 在 resources 编写一个自己的 META-INF\spring.factories
  • 放入 jar 包中（安装到maven仓库）

SpringBoot_第3张图片

2.4.SpringBoot配置文件

SpringBoot默认会从Resources目录下加载application.properties或application.yml文件

  <resources>
            <resource>
                <filtering>truefiltering>
                <directory>${basedir}/src/main/resourcesdirectory>
                <includes>
                    <include>**/application*.ymlinclude>
                    <include>**/application*.yamlinclude>
                    <include>**/application*.propertiesinclude>
                includes>
            resource>
            <resource>
                <directory>${basedir}/src/main/resourcesdirectory>
                <excludes>
                    <exclude>**/application*.ymlexclude>
                    <exclude>**/application*.yamlexclude>
                    <exclude>**/application*.propertiesexclude>
                excludes>
            resource>
        resources>

其中，application.properties文件是键值对类型的文件。除了properties文件外，SpringBoot还可以使用yml文件进行配置，下面对yml文件进行讲解。

server:
  port: 8087
spring:
  application:
    name: auth-service
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
    registry-fetch-interval-seconds: 10
  instance:
    lease-renewal-interval-in-seconds: 5 # 每隔5秒发送一次心跳
    lease-expiration-duration-in-seconds: 10 # 10秒不发送就过期
leyou:
  jwt:
    secret: leyou@Login(Auth}*^31)&heiMa% # 登录校验的密钥
    pubKeyPath: C:\\tmp\\rsa\\rsa.pub # 公钥地址
    priKeyPath: C:\\tmp\\rsa\\rsa.pri # 私钥地址
    expire: 30 # 过期时间,单位分钟
    cookieName: LY_TOKEN # token
  • 注意：value之前有一个空格
  • 在 yml 语法中，相同缩进代表同一个级别

拓展

SpringBoot_第4张图片

2.5.配置文件与配置类的属性映射方式

使用注解@ConfigurationProperties

通过注解@ConfigurationProperties(prefix="配置文件中的key的前缀")可以将配置文件中的配置自动与实体进行映射

person:
  name: zhangsan
  age: 18

@Controller
@ConfigurationProperties(prefix = "person")
public class QuickStartController {

    private String name;
    private Integer age;

    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
        return "springboot 访问成功! name="+name+",age="+age;
    }

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

    public void setAge(Integer age) {
        this.age = age;
    }
}

使用注解@Value映射

我们可以通过 @Value 注解将配置文件中的值映射到一个 Spring 管理的Bean的字段上

3.一些注解

@EnableAutoConfiguration

开启自动配置。SpringBoot基于你所添加的依赖和你自己定义的bean，试图去猜测并配置你想要的配置。比如我们引入了spring-boot-starter-web，而这个启动器中帮我们添加了tomcat、SpringMVC的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！

@SpringBootApplication

我们常使用一个启动类：

@SpringBootApplication
public class LeyouItemServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(LeyouItemServiceApplication.class);
    }
}

SpringBoot_第5张图片

发现 @SpringBootApplication其实是一个组合注解，这里重点的注解有3个：

  • @SpringBootConfiguration：在这个注解上面，又有一个@Configuration注解，作用就是声明当前类是一个配置类
  • @EnableAutoConfiguration：开启自动配置
  • @ComponentScan：开启注解扫描

@ConfigurationProperties

@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
    // ... 略
    // getters 和 setters
}
  • 在类上通过@ConfigurationProperties 注解声明当前类为属性读取类
  • prefix="jdbc"读取属性文件中，前缀为 jdbc 的值。

如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类（JdbcProperties）中。而是直接在需要的地方声明即可：

@Configuration
public class JdbcConfiguration {
    
    @Bean
    // 声明要注入的属性前缀，SpringBoot会自动把相关属性通过set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}
  • 使用的前提是：该类（DataSource）必须有对应属性的set方法！

我们可以通过@ConfigurationProperties读取并校验

可以参考

格式不正确，所以程序运行的时候就报错，根本运行不起来，保证了数据类型的安全性。

@EnableConfigurationProperties

@EnableConfigurationProperties注解的作用是：使用 @ConfigurationProperties 注解的类生效。

如果一个配置类只配置@ConfigurationProperties注解，而没有使用@Component，那么在IOC容器中是获取不到properties 配置文件转化的bean。说白了 @EnableConfigurationProperties 相当于把使用 @ConfigurationProperties 的类进行了一次注入。

@Configuration
@EnableConfigurationProperties(JwtProperties.class)
public class LeyouWebMvcConfiguration implements WebMvcConfigurer {
    @Autowired
    private LoginInterceptor loginInterceptor;
    @Autowired
    private JwtProperties jwtProperties;

    @Bean
    public LoginInterceptor loginInterceptor() {
        return new LoginInterceptor(jwtProperties);
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor).addPathPatterns("/**");
    }
}


@Component
@ConfigurationProperties(prefix = "leyou.jwt")
public class JwtProperties {

    private String pubKeyPath;// 公钥

    private PublicKey publicKey; // 公钥

    private String cookieName; //cookie

    private static final Logger logger = LoggerFactory.getLogger(JwtProperties.class);

    /**
     * @PostContruct：在构造方法执行之后执行该方法
     */
    @PostConstruct
    public void init(){
        try {
            // 获取公钥和私钥
            this.publicKey = RsaUtils.getPublicKey(pubKeyPath);

        } catch (Exception e) {
            logger.error("初始化公钥和私钥失败！", e);
            throw new RuntimeException();
        }
    }

}

4.整合SpringMVC

虽然默认配置已经可以使用 SpringMVC 了，不过我们有时候需要进行自定义配置。

设置 yml 文件

# 映射端口
server:
  port: 80

4.1.添加拦截器

通过实现WebMvcConfigurer并添加@Configuration注解来实现自定义部分SpringMvc配置。

首先我们定义一个拦截器：

@Component
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle method is running!");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle method is running!");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion method is running!");
    }
}

然后定义配置类，注册拦截器：

@Configuration
public class MvcConfiguration implements WebMvcConfigurer {

    @Autowired
    private HandlerInterceptor myInterceptor;

    /**
     * 重写接口中的addInterceptors方法，添加自定义拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor)
            					.addPathPatterns("/**")
            					.excludePathPatterns("/css/**","/js/**");
    }
}

使用 excludePathPatterns 设置白名单，允许放行的路径

4.2.静态资源访问问题

  1. 查看 WebMvcAutoConfiguration 的源码，有一个方法：addResourceHandlers 添加资源处理
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    if (!this.resourceProperties.isAddMappings()) {
        // 已禁用默认资源处理
        logger.debug("Default resource handling disabled");
        return;
    }
    // 缓存控制
    Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
    CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
    // webjars 配置
    if (!registry.hasMappingForPattern("/webjars/**")) {
        customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
                                             .addResourceLocations("classpath:/META-INF/resources/webjars/")
                                             .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
    }
    // 静态资源配置
    String staticPathPattern = this.mvcProperties.getStaticPathPattern();
    if (!registry.hasMappingForPattern(staticPathPattern)) {
        customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
                                             .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
                                             .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
    }
}

读一下源代码：比如所有的 /webjars/** ， 都需要去 classpath:/META-INF/resources/webjars/ 找对应的资源；官网

Webjars 本质就是以 jar 包的方式引入我们的静态资源 ， 我们以前要导入一个静态资源文件，直接导入即可。

要使用 jQuery，我们只要要引入jQuery对应版本的pom依赖即可！

<dependency>
    <groupId>org.webjarsgroupId>
    <artifactId>jqueryartifactId>
    <version>3.4.1version>
dependency>
  1. 再进入 ResourceProperties，发现如下配置：

SpringBoot_第6张图片

总结

  1. jar 包的 webjars 目录。 localhost:8080/wbjars/

  2. resource、 static 、 public 目录。 localhost:8080/

    优先级：resource > static > public

  3. 自定义静态资源路径：一旦自己定义了静态文件夹的路径，原来的自动配置就都会失效了！

spring.resources.static-locations=classpath:/coding/,classpath:/kuang/

注意，在 templates 目录下的 html 需要模板导入模板引擎使用；比如往后讲到的 Thymeleaf ，这里先提一下。

4.3.配置 Servlet

虽然现在几乎用不到servlet了，但是学习SpringBoot整合servlet有助于学习的深入了解，更好的理解框架。参考

第一种：推荐

  • 写一个类MyFirstServlet继承HttpServlet，并重写doGet方法。
  • 在类的上面用 @WebServlet 标识Servlet并指明 name 和 urlPatterns 。
  • 在标识有 @SpringBootApplication 的启动类上加上 @ServletComponentScan。
@WebServlet(name="MyFirstServlet",urlPatterns="/myFirst")
public class FirstServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("MyFirstServlet init............");
    }
    
     @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
    this.doGet(req,resp);
}

第二种：

  • 创建一个类SecondServlet继承 HttpServlet，并重写 doGet方法。这里就不需要@WebServlet 注解了
  • 在 @SpringBootApplication 标识的主类中加 @Bean 的一个方法。
@SpringBootApplication
//@ServletComponentScan //在springBoot启动时会扫描@WebServlet，并将该类实例化
public class ServletApplication {

   public static void main(String[] args) {
      SpringApplication.run(ServletApplication.class, args);
   }

  /**
 * 整合Servlet的第二种方式，创建ServletRegistrationBean并添加路径
 * @return
 */
@Bean
public ServletRegistrationBean getServletRegistrationBean(){
   ServletRegistrationBean bean = new ServletRegistrationBean(new SecondServlet());
   bean.addUrlMappings("/mySecond");
   return bean;
}

4.4.整合Filter、Listener

大致方式相同，讲一下思路吧：

第一种：

  • 创建一个MyFirstFilter类实现 Filter 接口，并在类上面标注 @WebFilter。
  • 在注解中 可以配置要拦截的路径
  • 在@SpringBootApplication的主类上加上@ServletComponentScan注解。

第二种：

  • 创建一个类MySecondFilter实现Filter接口，重写方法。
  • 在@SpringBootApplication标识的主类中加@Bean的一个方法，将MySecondFilter对象注入容器中。

整合Listener

第一种：

  • 创建一个类MyFirstListener实现 ServletContextListener 接口，重写方法
  • 在该类上加上@WebListener注解，
  • 在@SpringBootApplication的主类上加上@ServletComponentScan注解。在项目启动的时候，就会执行初始化 servlet，被Listener监听到

第二种：

  • 创建一个类MySecondListener实现 ServletContextListener 接口，重写方法。
  • 在@SpringBootApplication标识的主类中加@Bean的一个方法，将MySecondListener对象注入容器中。

5.整合Mybatis

导入起步依赖

 		
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
            <version>2.1.2version>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>

设置 yml

server:
  port: 8081
spring:
  application:
    name: item-service
  datasource:
    url: jdbc:mysql://localhost:3306/leyou
    username: root
    password: root
    hikari:
      max-lifetime: 28830000 # 一个连接的生命时长（毫秒），超时而且没被使用则被释放（retired），缺省:30分钟，建议设置比数据库超时时长少30秒，参考MySQL wait_timeout参数（show variables like '%timeout%';）
      maximum-pool-size: 9 # 连接池中允许的最大连接数。缺省值：10；推荐的公式：((core_count * 2) + effective_spindle_count)
 
mybatis:
  type-aliases-package: com.leyou.item.pojo
  mapper-locations: classpath:mapper/*.xml   # 想用xml写sql，需配置映射路径

xml 方式查表数据时，一般在 resources 目录下 建个目录，放入映射文件，与mapper名字对应。

SpringBoot_第7张图片
需要注意，这里没有配置 mapper 接口扫描包，因此我们需要给每一个Mapper接口添加@Mapper注解，才能被识别。

我们选择更简单的方式：使用 @MapperScan，在启动类上配置

@SpringBootApplication
@MapperScan("com.leyou.item.mapper")
public class LeyouItemServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(LeyouItemServiceApplication.class);
    }
}

创建实体Bean

public class User {
    // 主键
    private Long id;
    // 用户名
    private String username;
    // 密码
    private String password;
    // 姓名
    private String name;
  
    //此处省略getter和setter方法 .. ..
    
}

这里提一下，有时候报错：No beans of ‘BrandMapper’ type found；这是因为没有在mapper 上使用 Repository 注解，和在业务层加 servie 差不多意思。

5.1.通用mapper

通用Mapper的作者也为自己的插件编写了启动器，我们直接引入即可：


<dependency>
    <groupId>tk.mybatisgroupId>
    <artifactId>mapper-spring-boot-starterartifactId>
    <version>2.0.2version>
dependency>

定义一个接口，继承 Mapper接口即可使用，举个例子：

public interface BrandMapper extends Mapper<Brand> {//尽量使用#代替$，效率更高

    /**
     * 新增商品分类和品牌中间表数据
     * @param cid
     * @param id
     */
    @Insert("INSERT INTO tb_category_brand(category_id, brand_id) VALUES (#{cid}, #{bid})")
    void insertCategoryAndBrand(@Param("cid") Long cid,@Param("bid") Long id);


    @Select("SELECT * from tb_brand b INNER JOIN tb_category_brand cb on b.id=cb.brand_id where cb.category_id=#{cid}")
    List<Brand> selectBrandsByCid(Long cid);
}

5.2.整合事务

其实，我们引入 jdbc 或者 web 的启动器，就已经引入事务相关的依赖及默认配置了

   
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
        dependency>
        
        <dependency>
            <groupId>tk.mybatisgroupId>
            <artifactId>mapper-spring-boot-starterartifactId>
        dependency>
        
        <dependency>
            <groupId>com.github.pagehelpergroupId>
            <artifactId>pagehelper-spring-boot-starterartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>

至于事务，SpringBoot中通过注解来控制。就是我们熟知的@Transactional

    @Transactional  //勿忘添加事务注解
    public void saveBrand(Brand brand, List<Long> cids) {
        //先新增brand
        this.brandMapper.insertSelective(brand);//若未传参，不会像insert方法那样传null，只拼接传递参数，效率更高
        //在新增中间表
        cids.forEach(cid -> {
            this.brandMapper.insertCategoryAndBrand(cid, brand.getId());
        });
  • @Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。
  • 同样的，你也可以在括号内指定相应的属性：如（propagation、readOnly…）
  • 失效：当配置在非 public方法上、配置属性错误、数据库引擎不支持事务等情况便会失效

5.3.整合Spring Data JPA

不想使用 Mybatis ，我们也可以选择 整合Spring Data JPA

添加 Spring Data JPA 的起步依赖


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-jpaartifactId>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
dependency>

<dependency>
    <groupId>javax.xml.bindgroupId>
    <artifactId>jaxb-apiartifactId>
    <version>2.3.0version>
dependency>

配置 yml 关于命名策略

spring:
  application:
    name: item-service
  datasource:
    url: jdbc:mysql://localhost:3306/leyou
    username: root
    password: root
  jpa:
    database: MySQL
    show-sql: true
    generate-ddl: true
    hibernate:
      ddl-auto: update  # 第一次建表用create，后面使用update

创建实体配置实体

@Entity
public class User {
    // 主键
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    // 用户名
    private String username;
    // 密码
    private String password;
    // 姓名
    private String name;
 
    //此处省略setter和getter方法... ...
}

编写 UserRepository

public interface UserRepository extends JpaRepository<User,Long>{
    public List<User> findAll();
}

编写测试类

@RunWith(SpringRunner.class)
@SpringBootTest(classes=MySpringBootApplication.class)
public class JpaTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void test(){
        List<User> users = userRepository.findAll();
        System.out.println(users);
    }

}

6.整合 Junit 等工具

添加 Junit 的起步依赖

	
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
		
		<dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>jcl-over-slf4jartifactId>
            <version>1.7.21version>
        dependency>      
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
            <version>1.7.21version>
        dependency>
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.17version>
        dependency>
    dependencies>

编写测试类

@SpringBootTest
@RunWith(SpringRunner.class)
public class FastDFSTest {

    @Autowired
    private FastFileStorageClient storageClient;

    @Autowired
    private ThumbImageConfig thumbImageConfig;

    @Test
    public void testUploadAndCreateThumb() throws FileNotFoundException {
//        File file = new File("C:\\Users\\joedy\\Pictures\\xbx1.jpg");
        File file = new File("C:\\Users\\ccw\\Desktop\\1524297512647.jpg");
        // 上传并且生成缩略图
        StorePath storePath = this.storageClient.uploadImageAndCrtThumbImage(
                new FileInputStream(file), file.length(), "png", null);
        // 带分组的路径
        System.out.println(storePath.getFullPath());
        // 不带分组的路径
        System.out.println(storePath.getPath());
        // 获取缩略图路径
        String path = thumbImageConfig.getThumbImagePath(storePath.getPath());
        System.out.println(path);
    }
}

其中，

  • SpringRunner继承自SpringJUnit4ClassRunner，使用哪一个Spring提供的测试测试引擎都可以
  • @SpringBootTest的属性指定的是引导类的字节码对象

@SpringBootTest 说明

  • 之前我们使用@ContextConfiguration注解指定 locations属性（配置文件用），或者指定classes属性（注解的类）。如：@ContextConfiguration(locations= {"classpath:bean.xml"})
  • 同样的该注解也可以这么使用@SpringBootTest(classes = MySpringBootApplication.class)
  • 当没有指定，那么就是SpringBootContextLoader作为默认的ContextLoader。即引导类

整合 Swagger

官网：https://github.com/OAI/OpenAPI-Specification

  1. 导入依赖

<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger2artifactId>
    <version>2.9.2version>
dependency>


<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger-uiartifactId>
    <version>2.9.2version>
dependency>
  1. 配置 Swagger
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .host("http://order.leyou.com")
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.black.demo.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("My Swagger Document")
                .description("测试 ZTree 系统接口文档")
                .version("1.0")
                .build();
    }
}

配置多个分组

编写多个 Docket 实例，每个写上如下组名，注入容器即可

.groupName("GroupOne")

开发、发布环境切换

  • .enable(false) 会使 swagger 失效,达到效果
  • 在类上使用 @Profile(“dev”) 注解

spring boot允许你通过命名约定按照一定的格式(application-{profile}.properties)来定义多个配置文件，然后通过在application.properyies通过spring.profiles.active来具体激活一个或者多个配置文件，如果没有没有指定任何profile的配置文件的话，spring boot默认会启动application-default.properties。

  • 定义文件 application-dev.properties 和 application-prod.properties，
  • 在主配置文件 application.properties 中 选择激活哪个，如下
spring.profiles.active=dev
  1. 接口声明

常用注解说明：

/**
 @Api：修饰整个类，描述Controller的作用
 @ApiOperation：描述一个类的一个方法，或者说一个接口
 @ApiParam：单个参数描述
 @ApiModel：用对象来接收参数
 @ApiProperty：用对象接收参数时，描述对象的一个字段
 @ApiResponse：HTTP响应其中1个描述
 @ApiResponses：HTTP响应整体描述
 @ApiIgnore：使用该注解忽略这个API
 @ApiError ：发生错误返回的信息
 @ApiImplicitParam：一个请求参数
 @ApiImplicitParams：多个请求参数
 */

示例：

@RestController
@RequestMapping("order")
@Api("订单服务接口")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @Autowired
    private PayHelper payHelper;

    /**
     * 创建订单
     *
     * @param order 订单对象
     * @return 订单编号
     */
    @PostMapping
    @ApiOperation(value = "创建订单接口，返回订单编号", notes = "创建订单")
    @ApiImplicitParam(name = "order", required = true, value = "订单的json对象,包含订单条目和物流信息")
    public ResponseEntity<Long> createOrder(@RequestBody @Valid Order order) {
        Long id = this.orderService.createOrder(order);
        return new ResponseEntity<>(id, HttpStatus.CREATED);
    }

    /**
     * 根据订单编号查询订单
     *
     * @param id
     * @return
     */
    @GetMapping("{id}")
    @ApiOperation(value = "根据订单编号查询订单，返回订单对象", notes = "查询订单")
    @ApiImplicitParam(name = "id", required = true, value = "订单的编号")
    public ResponseEntity<Order> queryOrderById(@PathVariable("id") Long id) {
        Order order = this.orderService.queryById(id);
        if (order == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return ResponseEntity.ok(order);
    }

    /**
     * 分页查询当前用户订单
     *
     * @param status 订单状态
     * @return 分页订单数据
     */
    @GetMapping("list")
    @ApiOperation(value = "分页查询当前用户订单，并且可以根据订单状态过滤", notes = "分页查询当前用户订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "page", value = "当前页", defaultValue = "1", type = "Integer"),
            @ApiImplicitParam(name = "rows", value = "每页大小", defaultValue = "5", type = "Integer"),
            @ApiImplicitParam(name = "status", value = "订单状态：1未付款，2已付款未发货，3已发货未确认，4已确认未评价，5交易关闭，6交易成功，已评价", type = "Integer"),
    })
    @ApiResponses({
            @ApiResponse(code = 200, message = "订单的分页结果"),
            @ApiResponse(code = 404, message = "没有查询到结果"),
            @ApiResponse(code = 500, message = "查询失败"),
    })
    public ResponseEntity<PageResult<Order>> queryUserOrderList(
            @RequestParam(value = "page", defaultValue = "1") Integer page,
            @RequestParam(value = "rows", defaultValue = "5") Integer rows,
            @RequestParam(value = "status", required = false) Integer status) {
        PageResult<Order> result = this.orderService.queryUserOrderList(page, rows, status);
        if (result == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return ResponseEntity.ok(result);
    }
}

  1. 访问测试

    启动服务，然后访问：http://localhost:8089/swagger-ui.html

7.整合 Thymeleaf

SpringBoot 并不推荐使用 jsp ，但是支持一些模板引擎技术：

  • Freemarker
  • Thymeleaf
  • Mustache

开始使用

直接引入启动器：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-thymeleafartifactId>
dependency>

yml

server:
  port: 8084
spring:
  application:
    name: goods-web
  thymeleaf:
    cache: false
    mode: HTML

Thymelea f会在第一次对模板解析之后进行缓存，极大的提高了并发处理能力。但是这给我们开发带来了不便，修改页面后并不会立刻看到效果，我们开发阶段可以关掉缓存使用。

注意：

在Idea中，我们需要在修改页面后按快捷键：Ctrl + Shift + F9 对项目进行 rebuild 才可以。

编写html模板，渲染模型中的数据：

注意，把html 的名称空间，改成：xmlns:th="http://www.thymeleaf.org" 会有语法提示


<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首页title>
    <style type="text/css">
        table {border-collapse: collapse; font-size: 14px; width: 80%; margin: auto}
        table, th, td {border: 1px solid darkslategray;padding: 10px}
    style>
head>
<body>
<div style="text-align: center">
    <span style="color: darkslategray; font-size: 30px">欢迎光临！span>
    <hr/>
    <table class="list">
        <tr>
            <th>idth>
            <th>姓名th>
            <th>用户名th>
            <th>年龄th>
            <th>性别th>
            <th>生日th>
        tr>
        <tr th:each="user : ${users}">
            <td th:text="${user.id}">1td>
            <td th:text="${user.name}">张三td>
            <td th:text="${user.userName}">zhangsantd>
            <td th:text="${user.age}">20td>
            <td th:text="${user.sex}">男td>
            <td th:text="${user.birthday}">1980-02-30td>
        tr>
    table>
div>
body>
html>

SpringBoot会自动为 Thymeleaf 注册一个视图解析器：ThymeleafViewResolver

与解析 JSP 的InternalViewResolver类似，Thymeleaf也会根据前缀和后缀来确定模板文件的位置：

  • 默认前缀：classpath:/templates/
  • 默认后缀：.html

所以如果我们返回视图：item，会指向到 classpath:/templates/item.html

一般我们无需进行修改，默认即可。所以我们这样放置静态页面：

SpringBoot_第8张图片
示例控制类：

@Controller
@RequestMapping("item")
public class GoodsController {
    @Autowired
    private GoodsService goodsService;
    @Autowired
    private GoodsHtmlService goodsHtmlService;
    /**
     * 跳转到商品详情页
     * @param id
     * @param model
     * @return
     */
    @GetMapping("{id}.html")
    public String toItemPage(@PathVariable("id")Long id, Model model){
        Map<String, Object> map = this.goodsService.loadData(id);
        model.addAllAttributes(map);
        this.goodsHtmlService.createHtml(id);
        return "item";
    }
}

8.整合Redis

​ 在程序中可以使用缓存的技术来节省对数据库的开销。Spring Boot对缓存提供了很好的支持，我们几乎不用做过多的配置即可使用各种缓存实现。这里主要介绍平日里个人接触较多的 Redis 缓存实现。

添加redis的起步依赖：


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

配置 redis 的连接信息，默认端口为 6379：

spring:
  application:
    name: cart-service
  redis:
    host: 192.168.229.130

使用：

RedisTemplate 基本操作

Spring Data Redis 提供了一个工具类：RedisTemplate。里面封装了对于Redis的五种数据结构的各种操作，包括：

  • redisTemplate.opsForValue() ：操作字符串
  • redisTemplate.opsForHash()：操作hash
  • redisTemplate.opsForList()：操作 list
  • redisTemplate.opsForSet()：操作 set
  • redisTemplate.opsForZSet()：操作 zset

其它一些通用命令，如 expire，可以通过 redisTemplate.xx() 来直接调用

不过 RedisTemplate 默认会采用 JDK 自带的序列化（Serialize）来对对象进行转换。生成的数据十分庞大，因此一般我们都会指定 key 和 value 为 String 类型，这样就由我们自己把对象序列化为 json 字符串来存储即可。

Spring就默认提供了这样一个实现： StringRedisTemplate

StringRedisTemplate

使用了 key 和 value 都为 String 的 RedisTemplate ，便于我们阅读开发

public class StringRedisTemplate extends RedisTemplate<String, String> {

	/**
	 * Constructs a new StringRedisTemplate instance. {@link #setConnectionFactory(RedisConnectionFactory)}
	 * and {@link #afterPropertiesSet()} still need to be called.
	 */
	public StringRedisTemplate() {
		RedisSerializer<String> stringSerializer = new StringRedisSerializer();
		setKeySerializer(stringSerializer);
		setValueSerializer(stringSerializer);
		setHashKeySerializer(stringSerializer);
		setHashValueSerializer(stringSerializer);
	}
}

举例使用：

@Service
public class CartService {
    @Autowired
    private StringRedisTemplate redisTemplate;
    
   /**
     * 查询购物车
     * @return
     */
    public List<Cart> queryCarts() {
        UserInfo userInfo = LoginInterceptor.getUserInfo();
        // 判断是否存在购物车
        String key = KEY_PREFIX + userInfo.getId();
        if(!this.redisTemplate.hasKey(key)){
            // 不存在，直接返回
            return null;
        }
        //获取用户的购物车记录
        BoundHashOperations<String, Object, Object> hashOperations = this.redisTemplate.boundHashOps(key);
       //获取购物车Map中的Cart值
        List<Object> cartsJson =hashOperations.values();
        // 判断是否有数据
        if(CollectionUtils.isEmpty(cartsJson)){
            return null;
        }
        //遍历序列化， 把List转化为 List集合
        return cartsJson.stream().map(cartJson-> JsonUtils.parse(cartJson.toString(),Cart.class)).collect(Collectors.toList());

    }
 
  
9.SpringBoot异步任务
 
  
什么叫做任务呢？其实就是类中实现了一个什么功能的方法。常见的任务就是异步任务，定时任务，发邮件。
 
  
​ 异步任务：其实就是一个很特别的方法，这个方法没有返回值（也可以有返回值，后面会说的），但是方法内部的逻辑会耗费很多时间！例如，用户请求每次到controller，要执行到这个异步方法的时候，我们只需要命令一个空闲状态的线程去执行它即可，由于没有返回值不影响后续代码的运行，controller直接去执行后续的代码。这样可以极为迅速的响应用户，用户体验非常好。
 
  
​ 定时任务：这个其实看名字就知道了，你可以选定一个月的哪一天哪个小时的具体时分秒，去执行一个方法。这个方法是自动执行的，极大的减轻了我们的工作量。
 
  
发邮件：这个还是比较常见的吧！注册什么的大多都要邮件激活，我们也可以用java程序的方式，来给你邮箱发邮件。
 
  
 
   
简单说说异步任务和 RabbitMQ
 
  
 
  
异步任务和 RabbitMQ 最大的区别应该是访问量的差异；可以将异步任务看作是简化版RabbitMQ 。
 
  
那假如是异步任务：还是用订单/库存系统举例，几千人都在买买买，一时间几千个订单请求到controller，然后调用service（注：service还是跟上面一样要几十秒），一到service，判断是个异步方法，于是赶紧让处理异步任务的线程过来慢慢处理就好，controller可以直接响应用户“订单成功”。用户极短时间就收到响应，于是可以继续买买买。
 
  
这里就要说个东西，那个处理异步方法的线程哪里来的啊？其实是从异步方法线程池里拿的。大家应该知道连接池啊，是处理与数据库连接问题的，还能设置个数，最大超时时间等等，还能防止频繁的销毁创建线程的资源消耗。这里的线程池也差不多，可以设置个数啊什么的。。。。后面我们就会试试简单的配置一个连接池专门处理异步任务。
 
  
 
   
自定义异步任务的线程池
 
  
 
  
以下内容参考自
 
  
其实也是可以用多线程来做的，只是每次都用多线程比较麻烦，不过小伙伴们可以试试。线程池就相当于包装了一下多线程的操作，做了很多配置！就类似 ArrayList 和 Object 数组的关系。
 SpringBoot_第9张图片
 
  
使用注解 @Async（“自己配置的线程池的名字”），这里可以指定配置的哪个线程池，可以自己试试，我们这里要写应该是 taskExecutor）
 
  
SpringBoot_第10张图片
 
  
 
   
给异步方法设置返回值
 
  
 
  
前面说的都是异步方法返回值为 void 的情况，但是有的时候我们要拿到异步方法的返回值。
 
  
​ 举个例子，当请求到controller，线程就会去执行controller方法，碰到了要执行一个异步方法，于是异步方法立马返回一个 Future 对象敷衍 controller 一下（假如子线程还没处理完，那此时的Future里面是空的，主线程自然会阻塞,先立马给你返回空的Future对象,此时主线程一边继续往下执行，一边等子线程传数据过来;如果子线程执行完成了，会立马返回值），然后继续执行controller后面的方法
 
  
这个Future就是异步方法的返回值，只是刚开始还没有数据，等异步方法执行完毕，自动的就会将数据放入Future，比较常见的是利用Future来捕获异常。
 
  
其中，Future是个接口，实现类是AsyncResult，下面就看看修改后的 controller：
 
  
SpringBoot_第11张图片
 
  
再看看异步方法内部代码：
 
  
SpringBoot_第12张图片
 
  
9.1.定时任务
 
  
定时任务可以设置精确到秒的准确时间去自动执行方法。
 
  
使用 @Scheduled 注解
 
  
SpringBoot_第13张图片
 
  
然后，在主配置类上开启如下注解：
 
  
@SpringBootApplication
@EnableAsync
@EnableScheduling
public class AsyncAplication{
}

 
  
9.2.发邮件
 
  
引入依赖 参考博客
 
  
<dependency>
   <groupId>org.springframework.bootgroupId>
   <artifactId>spring-boot-starter-mailartifactId>
dependency>

<dependency>
   <groupId>org.springframework.bootgroupId>
   <artifactId>spring-boot-starter-thymeleafartifactId>
dependency>

<dependency>
   <groupId>org.springframework.bootgroupId>
   <artifactId>spring-boot-starter-webartifactId>
dependency>

<dependency>
   <groupId>org.projectlombokgroupId>
   <artifactId>lombokartifactId>
dependency>

 
  
配置文件
 
  
spring:
  mail:
    host: stmp.qq.com
    username: [email protected]
    password: xxx # 注意这里不是邮箱密码，而是SMTP授权密码
    protocol: smtp
    default-encoding: utf-8

 
  
MailService.java
 
  
@Service
public class MailService {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Value("${spring.mail.username}")
    private String from;

    @Autowired
    private JavaMailSender mailSender;

    /**
     * 简单文本邮件
     * @param to 接收者邮件
     * @param subject 邮件主题
     * @param contnet 邮件内容
     */
    public void sendSimpleMail(String to, String subject, String contnet){

        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(contnet);
        message.setFrom(from);

        mailSender.send(message);
    }

    /**
     * HTML 文本邮件
     * @param to 接收者邮件
     * @param subject 邮件主题
     * @param contnet HTML内容
     * @throws MessagingException
     */
    public void sendHtmlMail(String to, String subject, String contnet) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();

        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(contnet, true);
        helper.setFrom(from);

        mailSender.send(message);
    }

    /**
     * 附件邮件
     * @param to 接收者邮件
     * @param subject 邮件主题
     * @param contnet HTML内容
     * @param filePath 附件路径
     * @throws MessagingException
     */
    public void sendAttachmentsMail(String to, String subject, String contnet,
                                    String filePath) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();

        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(contnet, true);
        helper.setFrom(from);

        FileSystemResource file = new FileSystemResource(new File(filePath));
        String fileName = file.getFilename();
        helper.addAttachment(fileName, file);

        mailSender.send(message);
    }

    /**
     * 图片邮件
     * @param to 接收者邮件
     * @param subject 邮件主题
     * @param contnet HTML内容
     * @param rscPath 图片路径
     * @param rscId 图片ID
     * @throws MessagingException
     */
    public void sendInlinkResourceMail(String to, String subject, String contnet,
                                       String rscPath, String rscId) {
        logger.info("发送静态邮件开始: {},{},{},{},{}", to, subject, contnet, rscPath, rscId);

        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = null;

        try {

            helper = new MimeMessageHelper(message, true);
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(contnet, true);
            helper.setFrom(from);

            FileSystemResource res = new FileSystemResource(new File(rscPath));
            helper.addInline(rscId, res);
            mailSender.send(message);
            logger.info("发送静态邮件成功!");

        } catch (MessagingException e) {
            logger.info("发送静态邮件失败: ", e);
        }

    }

}


 
  
我们使用 thymeleaf 作为模板引擎。
 
  
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"/>
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"/>
    <meta http-equiv="X-UA-Compatible" content="ie=edge"/>
    <title>注册-测试邮件模板title>
head>
<body>
    你好，感谢你的注册，这是一封验证邮件，请点击下面的连接完成注册，感谢您的支持。
    <a href="#" th:href="@{https://github.com/{id}(id=${id})}">激活账户a>
body>
html>


 
  
测试代码
 
  
@RunWith(SpringRunner.class)
@SpringBootTest
public class MailServiceTest {

    @Autowired
    private MailService mailService;

    @Resource
    private TemplateEngine templateEngine;

    @Test
    public void sendSimpleMail() {
        mailService.sendSimpleMail("[email protected]","测试spring boot imail-主题","测试spring boot imail - 内容");
    }

    @Test
    public void sendHtmlMail() throws MessagingException {

        String content = "\n" +
                "\n" +
                "
hello world
\n" +
                "
html
\n" +
                "\n" +
                "\n";

        mailService.sendHtmlMail("[email protected]","这是一封HTML邮件",content);
    }

    @Test
    public void sendAttachmentsMail() throws MessagingException {
        String filePath = "/ijiangtao/软件开发前景.docx";
        String content = "\n" +
                "\n" +
                "
hello world
\n" +
                "
html
\n" +
                "
附件传输
\n" +
                "\n" +
                "\n";
        mailService.sendAttachmentsMail("[email protected]","这是一封HTML邮件",content, filePath);
    }

    @Test
    public void sendInlinkResourceMail() throws MessagingException {
        //TODO 改为本地图片目录
        String imgPath = "/ijiangtao/img/blob/dd9899b4cf95cbf074ddc4607007046c022564cb/blog/animal/dog/dog-at-work-with-computer-2.jpg?raw=true";
        String rscId = "admxj001";
        String content = "" +
                "" +
                "
hello world
" +
                "
html
" +
                "
图片邮件
" +
                "" +
                "" +
                "";

        mailService.sendInlinkResourceMail("[email protected]","这是一封图片邮件",content, imgPath, rscId);
    }

    @Test
    public void testTemplateMailTest() throws MessagingException {
        Context context = new Context();
        context.setVariable("id","ispringboot");

        String emailContent = templateEngine.process("emailTeplate", context);
        mailService.sendHtmlMail("[email protected]","这是一封HTML模板邮件",emailContent);

    }
}


 
  
10.安全框架
 
  
目前用的最多的是权限框架有两个：Shiro 和 Spring Security，Shiro 底层也是用 Spring Security， Spring Security 更复杂但是更强大。
 
  
     
   
  • Spring Security：待学习 
    
       
     
    • 参考博客
      •  
     
    • 参考w3c
      •  
    
     
    •  
   
  • Shiro：待学习 
    
       
     
    • 参考链接
      •  
    
     
    •  
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(学习笔记)

        

            

                
    
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • 语文主题教学学习笔记之87
                        东哥杂谈

                        
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
    
                    
    • 
                    
  • 《转介绍方法论》学习笔记
                        小可乐的妈妈

                        
    一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • 新能源汽车 BMS 学习笔记篇—BMS 基本定义及分类
                        WPG大大通
其他笔记汽车BMS经验分享新能源电池
                        
    一、BMS定义1、概念：BMS（BatteryManagementSystem）即电池管理系统，其管理对象是二次电池（充电电池或蓄电池），其主要目的是电池的利用率，防止电池出现过度充电和过度放电，可应用于电动汽车、电瓶车、机器人、无人机等图片来源：腾讯网https://new.qq.com《标准普尔警告，电动汽车电池生产面临供应链和地缘政治风险》2、四大功能①感知和测量：检测电池的电压、电流、温度
    
                    
    • 
                    
  • 吴恩达深度学习笔记(30)-正则化的解释
                        极客Array

                        
    正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
    
                    
    • 
                    
  • 个人学习笔记7-6：动手学深度学习pytorch版-李沐
                        浪子L
深度学习深度学习笔记计算机视觉python人工智能神经网络pytorch
                        
    #人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
    
                    
    • 
                    
  • golang学习笔记--MPG模型
                        xxzed
golang#学习笔记学习笔记golang
                        
    MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
    
                    
    • 
                    
  • 碎片化学习笔记分享
                        剑客写作

                        
    现在生活节奏很快，学习力成为了我们拥有的最大财富。碎片化学习是最好的。首先，不要太过自信，学会虚心学习，是我们面对现实的好方法，才能够常保新鲜。平时我们要拥有什么工具呢？1.思维导图2.写在印象笔记里3.听书，消燥耳机4.教学输出5.录音笔里面最好的方式就是教学输出法，记忆里最好。当输出时我们集中精力记忆里最好。有人认为缩短睡眠时间来学习，其实最好的方式是保持最好的睡眠，记忆力会更好。剥夺睡眠，会
    
                    
    • 
                    
  • 《随园诗话》学习笔记三百零六
                        飞鸿雪舞

                        
    卷五凡诗之传者，都在灵性五、五斗米与诗【原文】丁丑，余觅一抄书人，或荐黄生，名之纪，号星岩者，人甚朴野。偶过其案头，得句云；“破庵僧卖临街瓦，独井人争向晚泉。”余大奇之，即饷米五斗。自此欣然大用力于诗。五言句云：“云开日脚直，雨落水纹圆。竹锐穿泥壁，蝇酣落酒尊。钓久知鱼性，樵多识树名。笔残芦并用，墨尽指同磨。＂七言云：＂小窗近水寒偏觉，古木遮天曙不知。旧生萍处泥犹绿，新落花时水亦香。旧甓恐闲都贮水
    
                    
    • 
                    
  • D15 论语学习笔记
                        许小兔Angelina

                        
    悟：上级对下级的宽容：凡事成定局，就不你说了；已接近完结的事，也没必要匡正和挽回了；既然是过去的事，也没必要追究得失和责任了。对待孩子教育也是，不用“问责制”，这样容易让孩子因为害怕担责而说谎。应当循循善诱，避免再犯错才是最重要的。3.16：【原文】子曰：“射不主皮，为力不同科，古之道也。”【译文】孔子说：“射箭比赛不以射透为主，而主要看是否射得准确，因为人的力量不同，自古如此。”3.17：【原文
    
                    
    • 
                    
  • 网络工程师学习笔记（一）
                        专业白嫖怪
网络工程师学习笔记学习笔记网络
                        
    为了备战下半年的软考——网络工程师，利用每天的下班的闲暇时间看书听课，然后自己手敲整理的系列资料。希望能够对你们有所帮助第一章__计算机网络概述计算机网络的定义：将分散的具有独立运算功能的计算机系统，通过通信线路和通信设备进行连接起来的实现资源的共享。ARPAnet网络的特征：资源共享、分散控制、分组交换1946年第一台通用计算机—埃尼亚克能够相互连通进行数据交换。1960年提出巨型网络，出现了对
    
                    
    • 
                    
  • K8S学习笔记02——K8S组件
                        沉淅尘
#Docker#K8Skubernetes
                        
    Kubernetes组件一、控制平面组件（ControlPlaneComponents）(1)kube-apiserver(2)etcd(3)kube-scheduler(4)kube-controller-manager(5)cloud-controller-manager二、Node组件1.kubelet2.kube-proxy3.容器运行时（ContainerRuntime）三、插件（Add
    
                    
    • 
                    
  • 「Python」2020.04.08学习笔记 | 第六章文件（a+）模式+把随机手机号写入文件小练习
                        Yetta的书影屋

                        
    学习测试开发的Day97，真棒！学习时间为40M第九次全天课(下午视频二20M-50M）>>>fp.seek(0)0>>>fp.read()'你好11你好12你好13你好14你好15\n你好16\n你好17\n你好18\n'>>>fp.seek(0,0)0>>>fp.write("*********************************\n")34>>>fp.seek(0,0)0>>>f
    
                    
    • 
                    
  • 《金文成〈中庸〉学习笔记401。2020-2-24》
                        金吾生

                        
    《金文成〈中庸〉学习笔记401。2020-2-24》今天是庚子年戊寅月丁酉日，二月初二，2020年2月24日星期一。二月二龙抬头。第二十二章【唯天下至诚，为能尽其性；能尽其性，则能尽人之性；能尽人之性，则能尽物之性；能尽物之性，则能赞天地之化育；能赞天地之化育，则可以与天地参矣。】上一节，船山讲解说，性作为天用之本体，于圣人和匹夫匹妇而言并无二致，区别来自于诚。诚的区别来自于纯粹与掺杂。掺杂什么呢
    
                    
    • 
                    
  • CDGA学习笔记三-《数据安全》
                        zy_chris
网络安全
                        
    七、数据安全7.1引言数据安全包括安全策略和过程的规划、建立与执行，为数据和信息资产提供正确的身份验证、授权、访问和审计。要求来自以下方面：（1）利益相关方（2）政府法规（3）特定业务关注点（4）合法访问需求（5）合同义务7.1.1业务驱动因素1、降低风险信息安全首先对组织数据进行分级分类，对组织数据进行分类分级的整个流程：1）识别敏感数据资产并分类分级2）在企业中查找敏感数据3）确定保护每项资产
    
                    
    • 
                    
  • vue学习笔记——关于对Vue3 ref(), toRef(), toRefs(), unref(), isRef(), reactive()方法的理解。
                        chen_sir_sh
vue学习笔记javascript前端vue
                        
    VUE3出现了很多新的API，下面是自己的一些理解进行的总结。欢迎大家一起交流补充。ref()使用ref创建一个数据类型，ref有value这个属性constname1={age:"14",name:"bob1"};constname2=ref({name:"bob2"});//使用ref创建一个数据类型相对于reactive，ref有value属性name2.value="bob3"consol
    
                    
    • 
                    
  • 遇到僵尸进程，怎么处理---学习笔记
                        summer@彤妈
性能优化linux
                        
    僵尸进程解释当iowait升高时，进程很可能因为得不到硬件的响应，而长时间处于不可中断状态。从ps或者top命令的输出中，你可以发现它们都处于D状态，也就是不可中断状态（UninterruptibleSleep）。既然说到了进程的状态，进程有哪些状态你还记得吗？我们先来回顾一下。top和ps是最常用的查看进程状态的工具，我们就从top的输出开始。下面是一个top命令输出的示例，S列（也就是Stat
    
                    
    • 
                    
  • C++学习笔记----6、内存管理（五）---- 智能指针（3）
                        王俊山IT
c++学习笔记开发语言
                        
    2、shared_ptr有时候吧，有些对象或者一部分代码需要同一个指针的拷贝。那么unique_ptr不能被拷贝，因此就不能用于些场景。这样的话，std::shared_ptr就是一个支持能够被拷贝的拥有共享属主的智能指针。但是，如果有指向同一个资源的多个shared_ptr实例，那么怎么知道什么时候去释放资源呢？这可以通过对于引用记数来解决，这个我们以后再聊。首先，让我们看一下怎么构造与使用sh
    
                    
    • 
                    
  • 【学习笔记】武志红心理学—潜意识决定命运
                        万万千千

                        
    冰山一角什么构成了我们的命运？命运是由我们的显意识和潜意识来决定的。我们可以用一张图做一个比喻。看过“冰山一角”图片的都知道，潜意识就是水面以下的部分，显意识是水面以上的部分，从体积来看，潜意识占了大部分，而显意识只是冰山一角，纵向来看，庞大的潜意识支撑着冰山一角的显意识，才得以让冰山漂浮在水面。延伸到我们的人生，我们对自己显意识层面的想法很容易感知到，所以我们会说这是“我”自己做的选择。而潜意识
    
                    
    • 
                    
  • Prism 教程
                        yang_B621
PrismIOC
                        
    http://t.csdnimg.cn/VXSSvhttps://blog.csdn.net/u010476739/article/details/119341731Prism-随笔分类-Hello——寻梦者！-博客园(cnblogs.com)C#IoC学习笔记-缥缈的尘埃-博客园(cnblogs.com)WPF_SchuylerEX的博客-CSDN博客
    
                    
    • 
                    
  • 绘本讲师训练营【第30期】2/21阅读原创《绘本之力》学习笔记2
                        郑贤钰

                        
    30028郑贤钰今天读了绘本之力《留在灵魂里的东西》读了心里有非常大的感触！两个年幼什么都不懂的孩子，为了自己心爱的东西，攒下来自己的零花钱，却买了一个自己不知道怎么用的东西，当他们觉得这个东西根本就不好，准备扔掉的时候，这是故事中的有趣有爱的老爷爷出现了，帮助孩子们再一次发现之前别人拉出优美的音乐，原来自己买的这一个琴，自认为没用的琴也能够经过老爷爷熟练的演奏也能拉出这样优美的声音，这让孩子们十
    
                    
    • 
                    
  • 仿老师悟
                        耕海者

                        
    毕业十年了，今天去拜访老师，看到老师的学习笔记，看到老师努力学习，积极提高的状态，我觉着自己真是有些懈怠了，孩子们，老师的老师都在孜孜不倦，我们岂能偷懒！
    
                    
    • 
                    
  • C++学习笔记----7、使用类与对象获得高性能（一）---- 书写类（2）
                        王俊山IT
c++学习笔记开发语言
                        
    2.2、定义成员函数前面对SpreadsheetCell类的定义足以让你生成类的对象。然而，如果想调用setValue()或者getValue()成员函数，连接器就会抱怨这些函数没有定义。这是因为到目前为止，这些成员函数只有原型，而还没有实现。通常，类的定义会在模块接口文件。对于成员函数的定义，你有一个选择：可以在模块定义文件或者在模块实现文件。下面是SpreadsheetCell类，在类内对成员
    
                    
    • 
                    
  • Spring6学习笔记4：事务
                        ·云扬·
SSMJava#Spring学习笔记spring
                        
    1JdbcTemplate1.1简介Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作准备工作①搭建子模块搭建子模块：spring-jdbc-tx②加入依赖org.springframeworkspring-jdbc6.0.2mysqlmysql-connector-java8.0.30com.alibabadruid1.2.15③创建jdbc.propertie
    
                    
    • 
                    
  • 连通无向图一般中心的算法及其matlab程序详解
                        夏天天天天天天天#
图论算法matlab图论
                        
    #################本文为学习《图论算法及其MATLAB实现》的学习笔记#################若服务点只允许取在各顶点上,而服务对象却取在各顶点及各边(或弧)上的点,则在所有顶点中选定一个顶点作为图的一般中心其条件是该点离它本身的最远服务对象(包括顶点及各边(或弧)上的点)的距离达到极小值。寻找无向图的一般中心对解决网络最佳服务点确定的问题是十分有效的，使得服务对象的范围
    
                    
    • 
                    
  • 学习笔记：FW内容安全概述
                        TKE_yinian

                        
    内容安全概述信息安全概述主要威胁关于防护简介内容安全威胁应用层威胁内容安全技术WEB安全应用安全入侵防御检测邮件安全数据安全网络安全反病毒全局环境感知沙箱检测信息安全概述•信息安全是对信息和信息系统进行保护，防止未授权的访问、使用、泄露、中断、修改、破坏并以此提供保密性、完整性和可用性。•为关键资产提供机密性、完整性和可用性（CIA三元组）保护是信息安全的核心目标。CIA（Confidential
    
                    
    • 
                    
  • java的socket实现一个九宫棋游戏
                        睡不醒的小泽

                        
    前言一个简单的socket小作品=v=一个机酱在大三实验课中接触到很基础的JAVA语言socket编程。至于你问为什么嵌入式的机酱会弄些Java吗？emmmmm，可能是当初C语言版的不够好玩吧，另外如果碰巧有用，欢迎抱走的yoo在之前的笔记《网络基础知识和网络编程》中有讲解过关于网络编程的一些基本知识，以及一些LinuxC的socket编程，希望粗浅了解socket内部肌理的同学，右转咱的学习笔记
    
                    
    • 
                    
  • 【每日一词】D33 edge
                        宠辱不惊的中年少女

                        
    1）学习笔记：edge：优势，=advantagebeanabsoluteedge有绝对优势AhasanedgeoverB表示A比B更好maintainone'sedge保持优势loseone'sedge失去优势innovativeedge创新方面的优势2）查字典延伸：A.就工作经验而言，她显然要比我们面试过的其他人都胜出一筹。Intermsofexperience,shedefinitelyha
    
                    
    • 
                                
  • 矩阵求逆（JAVA）利用伴随矩阵
                                    qiuwanchi
利用伴随矩阵求逆矩阵
                                    
    package gaodai.matrix;

import gaodai.determinant.DeterminantCalculation;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * 矩阵求逆(利用伴随矩阵)
 * @author 邱万迟
 
    
                                
    • 
                                
  • 单例（Singleton）模式
                                    aoyouzi
单例模式Singleton
                                    
    3.1           概述 如果要保证系统里一个类最多只能存在一个实例时，我们就需要单例模式。这种情况在我们应用中经常碰到，例如缓存池，数据库连接池，线程池，一些应用服务实例等。在多线程环境中，为了保证实例的唯一性其实并不简单，这章将和读者一起探讨如何实现单例模式。 3.2
    
                                
    • 
                                
  • [开源与自主研发]就算可以轻易获得外部技术支持,自己也必须研发
                                    comsci
开源
                                    
     
 
      现在国内有大量的信息技术产品，都是通过盗版，免费下载，开源，附送等方式从国外的开发者那里获得的。。。。。。 
 
       虽然这种情况带来了国内信息产业的短暂繁荣，也促进了电子商务和互联网产业的快速发展，但是实际上，我们应该清醒的看到，这些产业的核心力量是被国外的
    
                                
    • 
                                
  • 页面有两个frame,怎样点击一个的链接改变另一个的内容
                                    Array_06
UIXHTML
                                    
    <a src="地址"  targets="这里写你要操作的Frame的名字" />搜索 
然后你点击连接以后你的新页面就会显示在你设置的Frame名字的框那里 
 
targerts="",就是你要填写目标的显示页面位置 
===================== 
例如： 
 
 <frame src=&
    
                                
    • 
                                
  • Struts2实现单个/多个文件上传和下载
                                    oloz
文件上传struts
                                    
    struts2单文件上传： 
    步骤01:jsp页面 
 
<!--在进行文件上传时，表单提交方式一定要是post的方式，因为文件上传时二进制文件可能会很大，还有就是enctype属性，这个属性一定要写成multipart/form-data，不然就会以二进制文本上传到服务器端--> 
　　<form action="fileUplo
    
                                
    • 
                                
  • 推荐10个在线logo设计网站
                                    362217990
logo
                                    
    在线设计Logo网站。 
1、http://flickr.nosv.org（这个太简单） 
2、http://www.logomaker.com/?source=1.5770.1 
3、http://www.simwebsol.com/ImageTool 
4、http://www.logogenerator.com/logo.php?nal=1&tpl_catlist[]=2 
5、ht
    
                                
    • 
                                
  • jsp上传文件
                                    香水浓
jspfileupload
                                    
    1. jsp上传 
 
Notice： 
1. form表单 method 属性必须设置为 POST 方法 ，不能使用 GET 方法 
2. form表单 enctype 属性需要设置为 multipart/form-data 
3. form表单 action 属性需要设置为提交到后台处理文件上传的jsp文件地址或者servlet地址。例如 uploadFile.jsp 程序文件用来处理上传的文
    
                                
    • 
                                
  • 我的架构经验系列文章 - 前端架构
                                    agevs
JavaScriptWeb框架UIjQuer
                                    
    框架层面：近几年前端发展很快，前端之所以叫前端因为前端是已经可以独立成为一种职业了，js也不再是十年前的玩具了，以前富客户端RIA的应用可能会用flash/flex或是silverlight，现在可以使用js来完成大部分的功能，因此js作为一门前端的支撑语言也不仅仅是进行的简单的编码，越来越多框架性的东西出现了。越来越多的开发模式转变为后端只是吐json的数据源，而前端做所有UI的事情。MVCMV
    
                                
    • 
                                
  • android ksoap2 中把XML(DataSet) 当做参数传递
                                    aijuans
android
                                    
    我的android app中需要发送webservice ，于是我使用了 ksop2 进行发送，在测试过程中不是很顺利,不能正常工作.我的web service 请求格式如下     
     
[html]  
view plain 
copy       
 
 <Envelope xmlns="http://schemas.
    
                                
    • 
                                
  • 使用Spring进行统一日志管理 + 统一异常管理
                                    baalwolf
spring
                                    
    统一日志和异常管理配置好后，SSH项目中，代码以往散落的log.info() 和 try..catch..finally 再也不见踪影！ 
统一日志异常实现类：    
[java]  
view plain 
copy       
 
 package com.pilelot.web.util;   
    
 impor
    
                                
    • 
                                
  • Android SDK 国内镜像
                                    BigBird2012
android sdk
                                    
    一、镜像地址： 
1、东软信息学院的 Android SDK 镜像，比配置代理下载快多了。 
配置地址， http://mirrors.neusoft.edu.cn/configurations.we#android 
2、北京化工大学的： 
IPV4:ubuntu.buct.edu.cn  
IPV4:ubuntu.buct.cn 
IPV6:ubuntu.buct6.edu.cn 

    
                                
    • 
                                
  • HTML无害化和Sanitize模块
                                    bijian1013
JavaScriptAngularJSLinkySanitize
                                    
    一.ng-bind-html、ng-bind-html-unsafe 
        AngularJS非常注重安全方面的问题，它会尽一切可能把大多数攻击手段最小化。其中一个攻击手段是向你的web页面里注入不安全的HTML，然后利用它触发跨站攻击或者注入攻击。 
        考虑这样一个例子，假设我们有一个变量存
    
                                
    • 
                                
  • [Maven学习笔记二]Maven命令
                                    bit1129
maven
                                    
    mvn compile 
compile编译命令将src/main/java和src/main/resources中的代码和配置文件编译到target/classes中，不会对src/test/java中的测试类进行编译 
MVN编译使用 
maven-resources-plugin:2.6:resources 
maven-compiler-plugin:2.5.1:compile 
&nbs
    
                                
    • 
                                
  • 【Java命令二】jhat
                                    bit1129
Java命令
                                    
    jhat用于分析使用jmap dump的文件，，可以将堆中的对象以html的形式显示出来，包括对象的数量，大小等等，并支持对象查询语言。 jhat默认开启监听端口7000的HTTP服务，jhat是Java Heap Analysis Tool的缩写 
1. 用法： 
[hadoop@hadoop bin]$ jhat -help

Usage:  jhat [-stack <bool&g
    
                                
    • 
                                
  • JBoss 5.1.0 GA:Error installing to Instantiated: name=AttachmentStore state=Desc
                                    ronin47

                                    
    进到类似目录 server/default/conf/bootstrap，打开文件 profile.xml找到： Xml代码<bean  
  
name="AttachmentStore"  
class="org.jboss.system.server.profileservice.repository.AbstractAtta
    
                                
    • 
                                
  • 写给初学者的6条网页设计安全配色指南
                                    brotherlamp
UIui自学ui视频ui教程ui资料
                                    
    网页设计中最基本的原则之一是，不管你花多长时间创造一个华丽的设计，其最终的角色都是这场秀中真正的明星——内容的衬托 
    我仍然清楚地记得我最早的一次美术课，那时我还是一个小小的、对凡事都充满渴望的孩子，我摆放出一大堆漂亮的彩色颜料。我仍然记得当我第一次看到原色与另一种颜色混合变成第二种颜色时的那种兴奋，并且我想，既然两种颜色能创造出一种全新的美丽色彩，那所有颜色
    
                                
    • 
                                
  • 有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。写一个函数实现。复杂度是什么。
                                    bylijinnan
java算法面试
                                    
    

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

/**
 * http://weibo.com/1915548291/z7HtOF4sx
 * #面试题#有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。
 * 写一个函数实现。复杂度是什么
    
                                
    • 
                                
  • struts2获得request、session、application方式
                                    chiangfai
application
                                    
    1、与Servlet API解耦的访问方式。 
a.Struts2对HttpServletRequest、HttpSession、ServletContext进行了封装，构造了三个Map对象来替代这三种对象要获取这三个Map对象，使用ActionContext类。 
-----> 
  
package pro.action;
import java.util.Map;
imp
    
                                
    • 
                                
  • 改变python的默认语言设置
                                    chenchao051
python
                                    
     import sys
 sys.getdefaultencoding() 
 可以测试出默认语言，要改变的话，需要在python lib的site-packages文件夹下新建： 
sitecustomize.py， 这个文件比较特殊，会在python启动时来加载，所以就可以在里面写上： 
import sys
sys.setdefaultencoding('utf-8') 
&n
    
                                
    • 
                                
  • mysql导入数据load data infile用法
                                    daizj
mysql导入数据
                                    
    我们常常导入数据！mysql有一个高效导入方法，那就是load data infile 下面来看案例说明 
 
基本语法： 
load data  [low_priority] [local] infile 'file_name txt' [replace | ignore] 
into table tbl_name 
[fields 
[terminated by't'] 
[OPTI
    
                                
    • 
                                
  • phpexcel导入excel表到数据库简单入门示例
                                    dcj3sjt126com
PHPExcel
                                    
      
跟导出相对应的，同一个数据表，也是将phpexcel类放在class目录下，将Excel表格中的内容读取出来放到数据库中 
<?php 
error_reporting(E_ALL); 
set_time_limit(0); 
?> 
<html> 
<head> 
<meta http-equiv="Content-Type" 
    
                                
    • 
                                
  • 22岁到72岁的男人对女人的要求
                                    dcj3sjt126com

                                    
    22岁男人对女人的要求是：一，美丽，二，性感，三，有份具品味的职业，四，极有耐性，善解人意，五，该聪明的时候聪明，六，作小鸟依人状时尽量自然，七，怎样穿都好看，八，懂得适当地撒娇，九，虽作惊喜反应，但看起来自然，十，上了床就是个无条件荡妇。 32岁的男人对女人的要求，略作修定，是：一，入得厨房，进得睡房，二，不必服侍皇太后，三，不介意浪漫蜡烛配盒饭，四，听多过说，五，不再傻笑，六，懂得独
    
                                
    • 
                                
  • Spring和HIbernate对DDM设计的支持
                                    e200702084
DAO设计模式springHibernate领域模型
                                    
    A：数据访问对象 
 
    DAO和资源库在领域驱动设计中都很重要。DAO是关系型数据库和应用之间的契约。它封装了Web应用中的数据库CRUD操作细节。另一方面，资源库是一个独立的抽象，它与DAO进行交互，并提供到领域模型的“业务接口”。 
   资源库使用领域的通用语言，处理所有必要的DAO，并使用领域理解的语言提供对领域模型的数据访问服务。
    
                                
    • 
                                
  • NoSql 数据库的特性比较
                                    geeksun
NoSQL
                                    
    Redis 是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。目前由VMware主持开发工作。 
  
1. 数据模型 
作为Key-value型数据库，Redis也提供了键（Key）和值（Value）的映射关系。除了常规的数值或字符串，Redis的键值还可以是以下形式之一： 
Lists （列表） 
Sets
    
                                
    • 
                                
  • 使用 Nginx Upload Module 实现上传文件功能
                                    hongtoushizi
nginx
                                    
    转载自： http://www.tuicool.com/wx/aUrAzm 
  
普通网站在实现文件上传功能的时候，一般是使用Python，Java等后端程序实现，比较麻烦。Nginx有一个Upload模块，可以非常简单的实现文件上传功能。此模块的原理是先把用户上传的文件保存到临时文件，然后在交由后台页面处理，并且把文件的原名，上传后的名称，文件类型，文件大小set到页面。下
    
                                
    • 
                                
  • spring-boot-web-ui及thymeleaf基本使用
                                    jishiweili
springthymeleaf
                                    
    视图控制层代码demo如下： 
  
@Controller
@RequestMapping("/")
public class MessageController {
	private final MessageRepository messageRepository;

	@Autowired
	public MessageController(Mes
    
                                
    • 
                                
  • 数据源架构模式之活动记录
                                    home198979
PHP架构活动记录数据映射
                                    
    hello!架构 
一、概念 
活动记录（Active Record）：一个对象，它包装数据库表或视图中某一行，封装数据库访问，并在这些数据上增加了领域逻辑。 
对象既有数据又有行为。活动记录使用直截了当的方法，把数据访问逻辑置于领域对象中。 
  
二、实现简单活动记录 
活动记录在php许多框架中都有应用，如cakephp。 
<?php
/**
 * 行数据入口类
 *
    
                                
    • 
                                
  • Linux Shell脚本之自动修改IP
                                    pda158
linuxcentosDebian脚本
                                    
    作为一名 
Linux SA，日常运维中很多地方都会用到脚本，而服务器的ip一般采用静态ip或者MAC绑定，当然后者比较操作起来相对繁琐，而前者我们可以设置主机名、ip信息、网关等配置。修改成特定的主机名在维护和管理方面也比较方便。如下脚本用途为：修改ip和主机名等相关信息，可以根据实际需求修改，举一反三！   
#!/bin/sh
#auto Change ip netmask ga
    
                                
    • 
                                
  • 开发环境搭建
                                    独浮云
eclipsejdktomcat
                                    
           最近在开发过程中，经常出现MyEclipse内存溢出等错误，需要重启的情况，好麻烦。对于一般的JAVA+TOMCAT项目开发，其实没有必要使用重量级的MyEclipse，使用eclipse就足够了。尤其是开发机器硬件配置一般的人。 
  
      &n
    
                                
    • 
                                
  • 操作日期和时间的工具类
                                    vipbooks
工具类
                                    
       大家好啊，好久没有来这里发文章了，今天来逛逛，分享一篇刚写不久的操作日期和时间的工具类，希望对大家有所帮助。 
 
 

/*
 * @(#)DataFormatUtils.java 2010-10-10
 * 
 * Copyright 2010 BianJing,All rights reserved.
 */
package test;

impor
    
                                
    •