皇天
皇天

微服务-03-SpringBoot

1. Spring Boot简介

Spring Boot的设计目的是用来简化新Spring应用的初始搭建以及开发过程。SpringBoot所具备的特征有：

  1. 可以创建独立的Spring应用程序，并且基于其Maven或Gradle插件，可以创建可执行的JARs和WARs
  2. 内嵌Tomcat或Jetty等Servlet容器
  3. 提供自动配置的“starter”项目对象模型（POMS）以简化Maven配置
  4. 尽可能自动配置Spring容器
  5. 提供准备好的特性，如指标、健康检查和外部化配置
  6. 绝对没有代码生成，不需要XML配置

Spring Boot官网：https://spring.io/projects/spring-boot/

Spring Boot启动结构图(图片太大了，可单独查看图片)：

Spring Boot启动过程：

一路追踪源码：
SpringApplication.run()
// 先new对象，然后run
new SpringApplication(primarySources).run(args)

// new对象的构造方法
public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    // 配置Source
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    // 判断是否为web环境
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    this.bootstrappers = new ArrayList<>(getSpringFactoriesInstances(Bootstrapper.class));
    // 创建初始化构造器，加载spring.factories文件中ApplicationContextInitializer对应的所有类
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 创建应用监听器，加载spring.factories文件中ApplicationListener对应的所有类
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 配置应用的主方法所在类
    this.mainApplicationClass = deduceMainApplicationClass();
}

// run方法：运行Spring应用程序，创建并刷新新的应用程序上下文
public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    // 应用启动计时器开始计时
    stopWatch.start();
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;
    configureHeadlessProperty();
    // 获取spring.factories文件中SpringApplicationRunListener对应的监听器
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 广播事件，应用启动监听器开始监听
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 准备环境
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
        configureIgnoreBeanInfo(environment);
        // 应用启动时的提示图标，可以在resources下创建一个banner.txt来修改启动时的打印信息
        Banner printedBanner = printBanner(environment);
        // 创建新的应用程序上下文
        context = createApplicationContext();
        context.setApplicationStartup(this.applicationStartup);
        // 准备新的应用程序上下文
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
        // 刷新新的应用程序上下文
        refreshContext(context);
        afterRefresh(context, applicationArguments);
        // 应用启动计时器结束计时
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
        // 上下文已经刷新，应用程序已经启动
        listeners.started(context);
        // 调用CommandLineRunner和ApplicationRunner
        callRunners(context, applicationArguments);
    } catch (Throwable ex) {
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }

    try {
        listeners.running(context);
    } catch (Throwable ex) {
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

2. 创建Spring Boot工程

需求：在页面展示hello, world

2.1 手工创建

  1. 创建Maven工程

  2. 在pom.xml中配置parent和web的起步依赖

    

    4.0.0

    com.52lhp
    hello
    1.0-SNAPSHOT

    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.1.4.RELEASE
    
    
    
        
            org.springframework.boot
            spring-boot-starter-web

  3. 创建启动类

    package com.lhp;

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

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

  4. 编写业务代码：

    package com.lhp.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {
    @RequestMapping("/hello")
    public String hello() {
        return "hello, world";
    }
}

  5. 运行启动类的main方法

2.2 通过Spring Initializr创建

在IDEA中创建工程时使用Spring Initializr

  1. 点击Next转到Spring Initializr Project Settings页面-->配置Group、Artifact、Packaging、Java Version、Package等
  2. 点击Next转到Dependencies页面-->选择Spring Boot的版本和需要的依赖-->Next-->Finish
  3. 右键模块-->Add Framework Support...-->选中Maven

2.3 部署Spring Boot项目

jar包部署：

  1. 在pom.xml中配置spring-boot-maven-plugin插件，将项目打成jar包

  2. 控制台执行命令

    java -jar xxx.jar

war包部署：

  1. 让启动类继承SpringBootServletInitializer
  2. 在pom.xml中配置spring-boot-maven-plugin插件，将项目打成war包
  3. 在Web服务器(如：Tomcat)中部署war包

3. Spring Boot配置文件

Spring Boot的很多配置都有默认值，可以使用application.properties或application.yml(application.yaml)来修改默认配置。SpringBoot默认从Resource目录加载自定义配置文件。

如果同时存在properties和yaml/yml，则properties优先级高于yaml/yml。

yaml/yml基本语法，参考：https://www.runoob.com/w3cnote/yaml-intro.html

  • 大小写敏感
  • 使用缩进表示层级关系
  • 缩进不允许使用tab，只允许空格
  • 缩进的空格数不重要，只要相同层级的元素左对齐即可
  • #表示注释
  • 值前面要加一个空格
  • 对象键值对使用冒号结构表示key: value
  • 以-开头的行表示构成一个数组
  • 纯量包括：字符串、布尔值、整数、浮点数、Null、时间、日期
  • &用来建立锚点，*用来引用锚点

3.1 获取配置文件中的值

  1. application.yml配置文件内容：

    person:
  name: lhp
  age: 21
  # 纯量数据类型
  sex: 男
  # 数组数据类型
  hobbies:
    - study
    - reading
  # 对象数据类型
  pet:
    name: 狗
    food: 骨头
    # 参数引用
    age: ${person.age}

  2. POJO：

    @Data
public class Pet implements Serializable {
    private String name;
    private String food;
    private Integer age;
}

// 1. 通过ConfigurationProperties把POJO的属性和yml中key的值自动建立映射关系
// 2. 将POJO交给Spring容器管理(POJO需要有Setter方法)
// 3. 使用时直接从Spring容器中获取该POJO
// 对象中的属性若有自身，则可能映射失败；如Person中含有Person
@Data
@Component
@ConfigurationProperties(prefix = "person")
public class Person implements Serializable {
    private String name;
    private Integer age;
    private String sex;
    private String[] hobbies;
    private Pet pet;
}

  3. 获取配置文件中的值：

    import com.lhp.demo.pojo.Person;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class TestController {
    // @Value("${属性名}")只能获取纯量
    @Value("${person.hobbies[0]}")
    private String personHobbies0;
    // 对象和数组的获取方式相同
    @Autowired
    private Person person;
    // 通过Environment可以获取纯量
    @Autowired
    private Environment environment;

    @GetMapping("/scalars")
    private String scalars() {
        System.out.println(environment.getProperty("person.hobbies[0]"));
        return "person.hobbies[0]=" + personHobbies0;
    }

    @GetMapping("/object")
    private String object() {
        return "person=" + person;
    }
}

3.2 使用指定的环境配置

  1. 方式1：编写多个配置文件application-xxx

    1. application.yml：

      # 通过active指定要使用的配置文件
spring:
  profiles:
    # active的值为application-后面的部分
    active: pro

    2. application-dev.yml：

      # 开发环境
server:
  port: 8081

    3. application-pro.yml：

      # 生产环境
server:
  port: 8082

    4. application-test.yml：

      # 测试环境
server:
  port: 8083

  2. 方式2：在application.yml中使用---来分割

    spring:
  profiles:
    active: dev
---
# 开发环境
server:
  port: 8081
spring:
  profiles: dev
---
# 生产环境
server:
  port: 8082
spring:
  profiles: pro
---
# 测试环境
server:
  port: 8083
spring:
  profiles: test

  • 激活profiles的方式：

    1. 方式1：如上，在配置文件中配置spring.profiles.active=环境

    2. 方式2：运行时指定参数

      java -jar xxx.jar --spring.profiles.active=test

    3. 方式3：配置jvm参数

      -Dspring.profiles.active=dev

4. Spring Boot整合其他框架

4.1 整合MyBatis

  1. 添加依赖：

    

    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    2.1.4



    mysql
    mysql-connector-java
    runtime

  2. 在application.yml中配置：

    spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?useSSL=false&serverTimezone=UTC&characterEncoding=utf-8
    username: root
    password: 123456
mybatis:
  # 配置mybatis映射文件的位置
  mapper-locations: classpath:com/lhp/integration/dao/*Dao.xml

  3. 在启动类上添加MapperScan注解，扫描Dao接口所在的包：

    import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
// MapperScan会扫描指定包下的所有的接口，然后将接口的代理对象交给Spring容器
@MapperScan(basePackages = "com.lhp.integration.dao")
public class IntegrationApplication {
    public static void main(String[] args) {
        SpringApplication.run(IntegrationApplication.class, args);
    }
}

4.2 整合JUnit

  1. 添加依赖：

    
    org.springframework.boot
    spring-boot-starter-test
    test

  2. 测试类所在的包最好在启动类所在的包下

  3. 低版本Spring Boot使用：

    package com.lhp.integration;

import com.lhp.integration.dao.UserDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class IntegrationApplicationTests {
    @Autowired
    private UserDao userDao;

    @Test
    public void contextLoads() {
        System.out.println(userDao.findAll());
    }
}

  4. 高版本Spring Boot使用：

    package com.lhp.integration;

import com.lhp.integration.dao.UserDao;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class IntegrationApplicationTests {
    @Autowired
    private UserDao userDao;

    @Test
    public void contextLoads() {
        System.out.println(userDao.findAll());
    }
}

4.3 整合Redis

  1. 添加依赖：

    
    org.springframework.boot
    spring-boot-starter-data-redis

  2. 在application.yml中配置：

    spring:
  redis:
    host: localhost
    port: 6379

  3. 在启动类中配置Redis序列化机制：

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

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

    // 配置Redis序列化机制
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        // 设置Key的序列化机制为StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        // 设置value的序列化机制为JdkSerializationRedisSerializer
        template.setValueSerializer(new JdkSerializationRedisSerializer());
        return template;
    }
}

  4. 使用：

    package com.lhp.integration;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
public class IntegrationApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void redisTest() {
        redisTemplate.boundValueOps("name").set("lhp");
        String name = String.valueOf(redisTemplate.boundValueOps("name").get());
        System.out.println(name);
    }
}

RedisTemplate支持的Redis序列化机制(RedisSerializer接口的实现类)：

  1. GenericJackson2JsonRedisSerializer
  2. GenericToStringSerializer
  3. Jackson2JsonRedisSerializer
  4. JdkSerializationRedisSerializer(默认)：要求key和value都实现Serializable接口
  5. OxmSerializer
  6. StringRedisSerializer
  7. 自己定义的RedisSerializer接口实现类

5. Spring Boot自动配置的原理

5.1 Condition接口

Condition接口和@Conditional注解是Spring4之后提供的，增加条件判断功能，可以选择性的注入Bean对象到Spring容器中。

自定义Condition实现类，需求：根据是否导入坐标，来选择是否加载Bean

  1. 是否导入的坐标：

    
    redis.clients
    jedis
    3.2.0

  2. POJO：

    public class User {
}

  3. 自定义Condition实现类：

    package com.lhp.study.condition;

import com.lhp.study.annotation.ConditionalOnClass;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Map;

public class OnClassCondition implements Condition {
    /**
     * @param context  上下文信息对象：可以获取环境信息、容器工程、类加载器对象
     * @param metadata 注解的元数据：可以获取注解的属性信息
     * @return 是否匹配条件，true匹配，false不匹配
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        /*try {
            Class.forName("redis.clients.jedis.Jedis");
            // 如果加载成功，则依赖已经导入，返回true
            return true;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            // 如果加载失败，则有依赖没有导入，返回false
            return false;
        }*/
        // 获取注解的属性信息
        Map annotationAttributes = metadata.getAnnotationAttributes(ConditionalOnClass.class.getName());
        // 获取注解中name的值
        String[] names = (String[]) annotationAttributes.get("name");
        for (String name : names) {
            try {
                Class.forName(name);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
                // 如果加载失败，则有依赖没有导入，返回false
                return false;
            }
        }
        // 如果指定的类都加载成功，则对应的依赖已经导入，返回true
        return true;
    }
}

  4. 自定义一个注解：

    package com.lhp.study.annotation;

import com.lhp.study.condition.OnClassCondition;
import org.springframework.context.annotation.Conditional;

import java.lang.annotation.*;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnClassCondition.class})
public @interface ConditionalOnClass {
    // 类全限定名的字符串数组
    String[] name() default {};
}

  5. 配置类：

    package com.lhp.study.config;

import com.lhp.study.annotation.ConditionalOnClass;
import com.lhp.study.condition.OnClassCondition;
import com.lhp.study.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    // @Conditional注解表示一个组件只有在value指定的所有条件都匹配时才有资格注册
    // @Conditional(value = OnClassCondition.class)
    @ConditionalOnClass(name = "redis.clients.jedis.Jedis")
    public User user() {
        return new User();
    }
}

  6. 在启动类中测试：

    package com.lhp.study;

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

@SpringBootApplication
public class StudyApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(StudyApplication.class, args);
        // 若导入坐标，则打印类信息；若没有导入坐标，则抛出NoSuchBeanDefinitionException
        System.out.println(context.getBean("user"));
    }
}

在org.springframework.boot.autoconfigure.condition包下有很多Spring已经定义好的Condition实现类和注解，如：

  1. ConditionalOnBean：当Spring容器中有某一个Bean时使用
  2. ConditionalOnClass：当目前类路径下有某一个类时使用
  3. ConditionalOnMissingBean：当Spring容器中没有某一个Bean时使用
  4. ConditionalOnMissingClass：当目前类路径下没有某一个类时使用
  5. ConditionalOnProperty：当配置文件中有某一个键值对时使用

5.2 切换内置的Web容器

org.springframework.boot.autoconfigure.web.embedded包下有4种Web容器定制器：

  1. JettyWebServerFactoryCustomizer
  2. NettyWebServerFactoryCustomizer
  3. TomcatWebServerFactoryCustomizer
  4. UndertowWebServerFactoryCustomizer

在spring-boot-starter-web中排除spring-boot-starter-tomcat依赖，然后添加其他的Web容器依赖即可：


    org.springframework.boot
    spring-boot-starter-web
    
        
        
            org.springframework.boot
            spring-boot-starter-tomcat
        
    



    org.springframework.boot
    spring-boot-starter-jetty

5.3 加载第三方的Bean

@SpringBootApplication上有@SpringBootConfiguration，而@SpringBootConfiguration上有@Configuration，因此启动类本身也是一个配置类，该配置类相当于Spring中的applicationContext.xml文件，用于加载配置使用。

@SpringBootApplication上有@EnableAutoConfiguration，这种@EnableXxx开头的注解是Spring Boot中定义的一些动态启用某些功能的注解，其底层原理实际上是用@import注解导入一些配置，来自动进行配置、加载Bean。

一路追踪源码：
@SpringBootApplication
@EnableAutoConfiguration
@Import({AutoConfigurationImportSelector.class})
String[] selectImports(AnnotationMetadata annotationMetadata)
AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata)
List getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes)
META-INF/spring.factories

在spring-boot-autoconfigure-x.x.x.jar中的META-INF/spring.factories文件中就有各种自动配置类

@SpringBootApplication上有@ComponentScan，而@ComponentScan类似于xml中的包扫描context:component-scan；如果不指定扫描路径，则扫描该注解修饰的启动类所在的包及子包。

@Import注解用于导入其他的配置，让Spring容器进行加载和初始化；其使用方式有：

  1. 直接导入Bean
  2. 导入配置类
  3. 导入ImportSelector的实现类
  4. 导入ImportBeanDefinitionRegistrar实现类

实现加载第三方的Bean示例：创建两个工程enable1和enable2，enable2中有Bean，enable1依赖enable2，期望在enable1中直接使用enable2中的Bean

  1. 在enable2中创建POJO和配置类：

    // POJO
package com.lhp.enable2.pojo;

public class User {
}

// 配置类
package com.lhp.enable2.config;

import com.lhp.enable2.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    public User user() {
        return new User();
    }
}

  2. 在enable1中添加第三方依赖enable2的坐标

  3. 在enable1的启动类中直接加载使用第三方依赖enable2中的Bean

  4. 解决NoSuchBeanDefinitionException：

    1. 方式1：在enable1的启动类上使用@ComponentScan("com")注解将包扫描路径放大

    2. 方式2：在enable1的启动类上使用@Import({UserConfig.class})注解导入配置类

    3. 方式3：自定义一个注解@EnableUser，然后在enable1的启动类上使用该注解

      // 自定义注解
package com.lhp.enable2.config;

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({UserConfig.class})
public @interface EnableUser {
}

    4. 方式4：自定义一个ImportSelector实现类，然后在enable1的启动类上使用@Import注解导入该实现类；此时不需要配置类

      // ImportSelector实现类
package com.lhp.enable2.config;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector implements ImportSelector {
    /**
     * @return 需要加载的Bean的全限定名数组
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 全限定名数组可以从配置文件中读取
        // 此时Bean的id为全限定名，可以通过getBean("com.lhp.enable2.pojo.User")或getBean(User.class)获取
        return new String[]{"com.lhp.enable2.pojo.User"};
    }
}

    5. 方式5：自定义一个ImportBeanDefinitionRegistrar实现类，然后在enable1的启动类上使用@Import注解导入该实现类；此时不需要配置类

      // ImportBeanDefinitionRegistrar实现类
package com.lhp.enable2.config;

import com.lhp.enable2.pojo.User;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        String beanName = "user";
        // 创建beanDefinition
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        // 注册Bean
        registry.registerBeanDefinition(beanName, beanDefinition);
    }
}

5.4 自定义starter起步依赖

需求：当加入jedis的坐标时，自动配置jedis的Bean，加载到Spring容器中

  1. 创建起步依赖工程starter，添加spring-boot-starter和jedis的坐标

  2. 创建配置的POJO：

    package com.lhp.starter.pojo;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

@Data
@ConfigurationProperties(prefix = "redis")
public class RedisProperties {
    // 给定默认值
    private String host = "localhost";
    private Integer port = 6379;
}

  3. 创建自动配置类

    // 自动配置类
package com.lhp.starter.autoconfigure;

import com.lhp.starter.pojo.RedisProperties;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;

@Configuration
// 启用POJO，交给Spring容器管理，与配置文件建立映射关系
@EnableConfigurationProperties(RedisProperties.class)
// 当类路径下有Jedis这个类时再使用这个配置类
@ConditionalOnClass(Jedis.class)
public class RedisAutoConfiguration {
    @Bean
    // 当没有jedis这个Bean时再配置，避免和用户自己的jedis冲突
    @ConditionalOnMissingBean(name = "jedis")
    public Jedis jedis(RedisProperties redisProperties) {
        System.out.println(redisProperties);
        return new Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}

  4. 在resources下创建META-INF/spring.factories文件：

    # Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.lhp.starter.autoconfigure.RedisAutoConfiguration

  5. 在其他工程中加入自定义的starter起步依赖的坐标，便可直接使用自定义starter起步依赖中的Bean

6. Spring Boot监控

6.1 Spring Boot Actuator

Spring Boot Actuator是Spring Boot自带的组件，可以监控Spring Boot应用，如健康检查、审计、统计、HTTP追踪等

使用Spring Boot Actuator：

  1. 添加依赖：

    
    org.springframework.boot
    spring-boot-starter-actuator

  2. 在application.yml中配置：

    management:
  # 配置健康端点开启所有详情信息
  endpoint:
    health:
      show-details: always
  # 设置开放所有web相关的端点信息
  endpoints:
    web:
      exposure:
        include: "*"
# 设置info前缀的信息
info:
  name: lhp
  age: 21

  3. 浏览器访问：http://localhost:8080/actuator

部分监控路径列表：

  1. /beans：描述应用程序上下文里全部的Bean及它们的关系
  2. /env：获取全部环境属性
  3. /env/{name}：根据名称获取特定的环境属性值
  4. /health：报告应用程序的健康指标，这些值由HealthIndicator的实现类提供
  5. /info：获取应用程序的定制信息，这些信息由info打头的属性提供
  6. /mappings：描述全部的URI路径，以及它们和控制器(包含Actuator端点)的映射关系
  7. /metrics：报告各种应用程序度量信息，比如内存用量和HTTP请求计数
  8. /metrics/{name}：报告指定名称的应用程序度量值
  9. /trace：提供基本的HTTP请求跟踪信息(时间戳、HTTP头等)

6.2 Spring Boot Admin

Spring Boot Admin是一个开源社区项目；它有两个角色，Client和Server；应用程序作为Client向Server注册；Server可以通过图形化界面展示Client的监控信息

  1. 每一个Spring Boot工程都是一个Client
  2. Server可以收集统计所有相关Client注册过来的信息，并进行汇总展示

使用Spring Boot Admin Server：

  1. 创建server工程，导入坐标：

    
    1.8
    2.3.1


    
        de.codecentric
        spring-boot-admin-starter-server
    
    
        org.springframework.boot
        spring-boot-starter-web
    


    
        
            de.codecentric
            spring-boot-admin-dependencies
            ${spring-boot-admin.version}
            pom
            import

  2. 在启动类上添加@EnableAdminServer注解来启用Server功能

  3. 在application.yml中配置：

    server:
  port: 8088

使用Spring Boot Admin Client：

  1. 创建server工程，导入坐标：

    
    1.8
    2.3.1


    
        org.springframework.boot
        spring-boot-starter-web
    
    
        de.codecentric
        spring-boot-admin-starter-client
    


    
        
            de.codecentric
            spring-boot-admin-dependencies
            ${spring-boot-admin.version}
            pom
            import

  2. 在application.yml中配置：

    spring:
  # 配置server的地址
  boot:
    admin:
      client:
        url: http://localhost:8088
  # 配置系统名称
  application:
    name: client
management:
  endpoint:
    health:
      # 启用健康检查(默认就是true)
      enabled: true
      # 配置显示所有的监控详情
      show-details: always
  endpoints:
    web:
      # 开放所有端点
      exposure:
        include: "*"

  3. 浏览器访问服务端地址：http://localhost:8088/

你可能感兴趣的:(微服务-03-SpringBoot)

  • 大语言模型为什么这么强？关键步骤是…… 青花科技 语言模型人工智能自然语言处理
    作者主页：青花锁简介：Java领域优质创作者、Java微服务架构公号作者简历模板、学习资料、面试题库、技术互助文末获取联系方式目录前言什么是大模型1.1、具备涌现能力1.2、多模态能力增强2、预训练往期热门专栏回顾前言研究人员发现，随着语言模型参数量的不断增加，模型完成各个任务的效果也得到不同程度的提升。什么是大模型大语言模型是指模型参数量超过一定规模的语言模型，相比参数量较小的预训练模型（如BE
  • ASP.NET Core 入门教学二十一 分布式追踪技术 充值内卷 asp.net分布式
    分布式追踪技术在微服务架构中非常重要，它可以帮助开发者理解和监控应用程序在分布式环境中的行为。ASP.NETCore提供了对分布式追踪的原生支持，主要通过OpenTelemetry和ApplicationInsights实现。1.OpenTelemetryOpenTelemetry是一个开源的观测框架，用于生成、收集和导出遥测数据（如追踪、指标和日志）。ASP.NETCore可以通过集成OpenT
  • 分布式事务 天黑了g 技术方案分布式后端微服务
    在微服务结构中，分布式事务是经常要考虑的问题。分布式事务解决方案有多种，有各自的优劣势和适用场景。主流的分布式事务框架库是阿里的seata，将根据seata库说明这些分布式事务的特点。尽量避免使用分布式事务。按照领域驱动设计思想，微服务之间是低耦合，微服务内部是高内聚，领域的限界上下文一般都在一个微服务里，那么微服务内的领域模型也是高内聚的。良好的架构设计只需在微服务里通过本地事务和领域事件就能够
  • Spring Cloud Alibaba(5)---Nacos(配置中心） Java代码狗 javaspringspringboot大数据linux
    有关SpringCloudAlibaba之前写过四篇文章，这篇也是在上面项目的基础上进行开发。SpringCloudAlibaba(1)---入门篇SpringCloudAlibaba(2)---RestTemplate微服务项目SpringCloudAlibaba(3)---Nacos概述SpringCloudAlibaba(4)---Nacos(注册中心）前言有关Nacos客户端的搭建和Nac
  • 就服务器而言，ARM架构与X86架构有什么区别？各自的优势在哪里？ 问就是想睡觉 服务器arm开发架构
    一、服务器架构概述在数字化时代，服务器架构至关重要。服务器是网络核心节点，存储、处理和提供数据与服务，是企业和组织信息化、数字化的关键基础设施。ARM和x86架构为服务器领域两大主要架构，x86架构服务器在市场占主导，有强大处理能力和广泛软件兼容性，广泛用于企业数据中心。ARM架构服务器近年崛起，凭借低功耗、高效能优势在云计算和微服务领域及嵌入式系统和物联网设备中有广泛应用。总之，两种架构各有优势
  • 【微服务】springboot 整合 SA-Token 使用详解 小码农叔叔 微服务治理与实战SA-Token使用详解sa-token使用详解sa-tokensa-token使用sa-token认证授权java使用sa-token
    目录一、前言二、认证与授权介绍2.1什么是认证2.1.1认证的目的2.1.2认证基本步骤2.2什么是授权2.2.1常用的授权模型三、微服务中常用的认证安全框架3.1SpringSecurity3.1.1SpringSecurity特点3.2JWT(JSONWebTokens)3.2.1JWT特点3.3其他认证安全框架四、SA-Token介绍4.1SA-Token是什么4.2SA-Token特点4.
  • SpringCloud基于Eureka的服务治理架构搭建与测试：从服务提供者到消费者的完整流程... 暴力小萝莉 springcloudeureka架构spring后端
    SpringCloud微服务框架中的Eureka是一个用于服务发现和注册的基础组件，它基于RESTful风格，为微服务架构提供了关键的服务注册与发现功能。以下是对Eureka的详细解析和搭建举例。一.Eureka基础知识（1）服务治理服务治理是微服务架构中最为核心和基础的模块，主要负责实现各个微服务实例的自动化注册与发现。服务治理能够管理服务之间的依赖关系，实现服务调用、负载均衡、容错等功能。Eu
  • 教你快速搭建微服务环境 糖心何包蛋· 微服务javaspringboot
    目录一、项目搭建1.父项目搭建2.子项目的搭建二、项目展示一、项目搭建1.父项目搭建步骤：1选择maven项目作为父项目，修改为1.8之后直接点击next2定义父项目的名称，修改ArtifctCoordinates--->GroupId然后点击finsh就可以啦3修改pom.xml1选择maven项目作为父项目，修改为1.8之后直接点击next2定义父项目的名称，修改ArtifctCoordina
  • 零基础搭建一套完整的微服务框架【window版】 superswang dockerjava微服务
    技术栈：springboot+dubbo+docker零基础搭即可建微服务，完整运行本文你想学到什么?本文将以实战方式，首先对“微服务”相关的概念进行概要介绍，然后开始手把手教你搭建这一整套完整的微服务系统。项目完整代码下载地址https://github.com/gggcgba/mall微服务架构解决了什么问题此系统建立完以后，你的整个系统将被拆分成一个个独立的子系统，独立运行，系统与系统之间通
  • 008-从零搭建微服务-系统服务（一） 「已注销」 微服务java架构
    模块规划后续服务都按下图结构创建，主要分为三块：mingyue-system系统服务聚合模块、mingyue-system-api系统服务公共API模块、mingyue-system-biz系统服务。mingyue-system-api系统服务公共API模块dto：请求入参类；entity：数据库实体类；feign：远程调用类；utils：工具包；vo：请求响应类；mingyue-system-b
  • SpringCloud基于Eureka的服务治理架构搭建与测试：从服务提供者到消费者的完整流程 招风的黑耳 后端eureka微服务
    SpringCloud微服务框架中的Eureka是一个用于服务发现和注册的基础组件，它基于RESTful风格，为微服务架构提供了关键的服务注册与发现功能。以下是对Eureka的详细解析和搭建举例。一.Eureka基础知识（1）服务治理服务治理是微服务架构中最为核心和基础的模块，主要负责实现各个微服务实例的自动化注册与发现。服务治理能够管理服务之间的依赖关系，实现服务调用、负载均衡、容错等功能。Eu
  • 96、Python消息队列与事件驱动：架构设计与实战案例 多多的编程笔记 架构kongconsul
    Python开发：熟悉API网关和服务发现（如Kong、Consul）引言在当今的软件开发领域，微服务架构已经成为了一种趋势。而在微服务架构中，API网关和服务发现机制扮演着至关重要的角色。本文将为大家介绍Python开发中如何熟悉API网关和服务发现，并以Kong和Consul为例，深入解析其应用场景和实用技巧。API网关什么是API网关API网关是一种服务器，作为客户端和后端服务之间的接口。它
  • API网关-Gateway笔记 天`南 gatewayspringcloudeureka
    一、API网关1.什么是API网关？API网关就是把各个服务对外提供的API汇聚起来，让外界看起来是一个统一的接口。同时也可以在网关中提供额外的功能。总结：网关就是所有项目的一个统一入口。2.网关的组成网关=路由转发（转发规则）+过滤器（额外功能）3.SpringCloudGateway介绍Gateway是SpringCloud的一个二级子项目，提供了微服务网关功能，包含：权限安全、监控/指标、谓
  • Spring Cloud OpenFeign 自定义结果解码器 飞空之羽 springcloud由浅入深spring
    我们在定义微服务接口的时候，通常会使用一个Result类进行封装，将提示信息，返回对象和状态码等内容封装到一起返回给调用方，例如如下的格式：publicclassResult{/***响应码，200为成功*/privateIntegercode;/***失败时的具体失败信息*/privateStringmessage;/***失败信息是否为用户提示，如果是的话框架不会主动拦截该错误*/privat
  • springcloud微服务 - 集成Zuul网关 无法通过网关 徐先生Paul springcloud微服务Zuul网关java微服务微服务架构cloud
    springcloud微服务-集成Zuul网关无法通过网关今天上午配置了下zuul网关，结果无法通过网关。具体如下：下面先贴下我做的动作。1、application.yml文件：server:port:9004eureka:instance:hostname:127.0.0.1client:service-url:defaultZone:http://${eureka.instance.hostn
  • springboot集成Zuul Flying_Fish_Xuan springboot后端java
    SpringBoot集成ZuulZuul是Netflix开源的API网关组件，主要用于微服务架构中的路由和过滤。在SpringCloud中，Zuul提供了一种动态路由机制，它将所有外部请求统一路由到具体的微服务中，同时可以对请求进行过滤、限流、鉴权等操作。Zuul已经进入维护模式，但在一些项目中仍然广泛使用。它的替代者是SpringCloudGateway。一、Zuul的功能路由功能：Zuul是请
  • 微服务注册中心都有哪些 xmh-sxh-1314 微服务
    在微服务架构中，注册中心扮演着至关重要的角色，用于服务的注册与发现。以下是一些常见的注册中心：Eureka：Eureka是Netflix开发的服务发现框架，后来贡献给了SpringCloud。它主要用于AWS云，但也可以在其他环境中运行。Eureka包含EurekaServer和EurekaClient两部分。Server提供服务的注册与发现，而Client则负责将服务注册到Server上，并从S
  • JavaEE进阶知识学习-----SpringCloud（十）SpringCloudConfig配置中心 四川码匠 SpringCloudJAVA进阶学习SpringCloud学习笔记SpringCloud
    SpringCloudConfig配置中心概述就前面项目而言，分布面临的问题是配置问题，每一个项目都有一个yml文件，不好运维管理，所有需要一套集中式，动态的配置管理设施，SpringCloud提供了ConfigServer来解决这个问题。SpringCloudConfig是为微服务架构中的微服务提供集中化的外部配置支持，配置服务器为各个不同的微服务应用的环境提供了一个中心化的外部配置。Sprin
  • Spring Boot项目中如何解决循环依赖 潘多编程 springbootjavaspring
    在SpringBoot项目中，循环依赖是一个常见的问题，尤其是在构建复杂的微服务架构时。当两个或多个Bean相互持有对方的引用时，就会形成循环依赖。Spring框架通过不同的机制来解决这个问题，以保证应用程序能够正确地启动并运行。下面我们将探讨几种处理循环依赖的方法，同时也深入了解一下Spring是如何处理Bean的初始化过程的。SpringBean的初始化过程在Spring容器中，Bean的生命
  • Spring Cloud全解析：注册中心之Eureka架构介绍 拾光师 springcloudjava
    Eureka架构介绍Eureka在设计时采用的是AP原则，是Netflix的一个子模块，用于微服务的服务注册与发现P:Partitiontolerance,网络分区容错。类似多机房部署，保证服务稳定性A:Availability，可用性C:Consistency，一致性对于任意一个系统只能同时满足两个，一个分布式系统不可能同时很好的满足一致性、可用性和分区容错性CA单点集群，满足一致性和可用性，在
  • 微服务——服务治理 一个搬砖的农民工 微服务解决方案微服务服务治理javaspringcloudnacos
    目录1什么是服务治理？2为什么需要服务治理？3服务治理的关键点3.1服务注册与发现3.2负载均衡3.3容错与熔断3.4服务监控与告警3.5服务配置管理4示例说明5总结1什么是服务治理？简单来说，服务治理就是对微服务架构中的服务进行管理、监控和控制的一系列技术和方法。它确保服务之间的调用、依赖和协作能够顺利进行，从而保障整个系统的稳定、可靠和高效。2为什么需要服务治理？随着微服务数量的增加，服务之间
  • Java与服务网格（Service Mesh）：构建高效微服务架构 爪哇抓挖_Java 日常架构javaservice_mesh
    在微服务架构成为企业开发标准的今天，如何有效地管理众多微服务之间复杂的通信成为了一个挑战。服务网格作为一种解决方案，它通过提供一个专门的基础设施层来处理服务间通信，从而使得应用开发更加专注于业务逻辑而非通信细节。本文将介绍服务网格的基本概念，探讨其在Java环境中的应用，并通过一个简单的示例演示如何使用Istio和SpringBoot来实现服务网格。什么是服务网格？服务网格是一种专门处理服务间通信
  • Service Mesh：Istio与Java微服务整合 ๑҉ 晴天 javaistiojava
    在现代微服务架构中，服务之间的通信变得越来越复杂。为了简化服务之间的交互、增强应用程序的安全性和可观察性，ServiceMesh技术应运而生。Istio是最流行的ServiceMesh解决方案之一，它提供了一系列强大的功能，如流量管理、安全通信和故障处理。在本文中，我们将讨论如何将Istio与Java微服务应用程序集成，并通过示例代码进行详细说明。1.什么是ServiceMesh？ServiceM
  • 网格化服务 java_准备好使用本机，服务网格化的Java Enterprise Cloud cunfu6353 dockerjavakubernetesspring大数据
    网格化服务java重要要点服务网格透明地为微服务添加了必需的技术横切关注点。诸如路由，弹性或身份验证之类的问题成为服务网格的责任。应用程序代码变得更加精简，并更加关注实际的业务逻辑。Istio通过Sidecar代理容器透明地增强了诸如KubernetesPod之类的工作负载。带有现代应用程序服务器的JavaEE通过使开发人员能够实施精益业务逻辑，可以与云原生技术很好地集成。JavaEE，云原生和服
  • Java中的服务网格（Service Mesh）架构解析 省赚客app开发者 javaservice_mesh架构
    Java中的服务网格（ServiceMesh）架构解析大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们将深入探讨服务网格（ServiceMesh）架构在Java应用中的实现与应用。服务网格是一种用于管理微服务之间通信的基础设施层，它提供了复杂的服务间通信管理、监控、安全性和可靠性功能。在微服务架构中，服务网格可以帮助简化服务间的通信，减少开发人员的负担。一、服
  • 深入探讨 Java 注册中心选型：构建高效微服务架构 需要重新演唱 架构java微服务
    深入探讨Java注册中心选型：构建高效微服务架构引言在现代微服务架构中，服务注册中心（ServiceRegistry）是不可或缺的一部分。它负责服务的注册、发现和管理，确保服务之间的通信高效且可靠。本文将深入探讨Java注册中心的选型，帮助你理解不同注册中心的特点和适用场景。无论你是初学者还是有经验的开发者，这篇文章都将为你提供全面而深入的理解。什么是服务注册中心？服务注册中心是一个集中式的服务管
  • java版本ERP管理系统源码 Spring Cloud alibaba Spring Boot MybatisPlus Redis VUE3 ElementUI 微服务 m0_66404702 javaspringbootredisERP管理系统源码
    在当今数字化浪潮的推动下，企业对于高效、稳定且易于扩展的管理系统需求日益增长。为了满足这一需求，我们精心打造了一款基于Java技术的鸿鹄ERP（EnterpriseResourcePlanning）管理系统。该系统充分利用了SpringCloudAlibaba、SpringBoot、MybatisPlus、Redis等先进技术栈，并结合前端框架VUE3和ElementUI，构建了一个功能丰富、性能
  • 深入理解微服务架构：演变、优势、挑战与核心技术20240905 Narutolxy 技术干货分享Go学习空间微服务架构云原生
    深入理解微服务架构：演变、优势、挑战与核心技术引言随着互联网应用的不断发展，传统的单体架构逐渐难以满足现代应用的需求。为了应对复杂多变的业务需求，微服务架构逐渐成为主流。本文将带您深入了解单体架构、SOA架构到微服务架构的演变过程，并探讨微服务架构的核心优势、挑战及其关键技术组件，如服务发现、链路跟踪、熔断、容器化、编排、服务网格等。1.从单体架构到微服务架构的演变1.1单体架构（Monolith
  • 微服务架构 kang1919 架构微服务云原生
    应用架构的变迁谈到微服务之前，首先我们通过下面图片简单了解一下应用架构的变迁单体架构在小型项目和早期阶段可能非常有效，但随着应用程序的增长和复杂性的增加，它逐渐暴露出可扩展性差、可维护性差、持续集成和持续部署（CI/CD）困难、资源利用效率低等问题。SOA（Service-OrientedArchitecture）即面向服务的架构，是一种软件架构风格，它通过将应用程序设计为一组相互独立的服务来实现
  • 服务发现的艺术：Eureka中实现分布式服务目录 代码之光_1980 服务发现eureka云原生
    标题：服务发现的艺术：Eureka中实现分布式服务目录在微服务架构中，服务的动态发现和注册是确保系统高可用性和可扩展性的关键。NetflixEureka是一个基于REST的服务发现框架，它提供了一个服务注册中心，使得服务实例可以注册和发现彼此。本文将详细解释如何在Eureka中实现分布式服务目录，并提供示例代码，帮助你构建一个高效的服务发现机制。1.微服务架构与服务发现在微服务架构中，服务通常是分
  • java Illegal overloaded getter method with ambiguous type for propert的解决 zwllxs javajdk
    好久不来iteye,今天又来看看，哈哈,今天碰到在编码时，反射中会抛出 Illegal overloaded getter method with ambiguous type for propert这么个东东，从字面意思看，是反射在获取getter时迷惑了，然后回想起java在boolean值在生成getter时，分别有is和getter，也许我们的反射对象中就有is开头的方法迷惑了jdk，
  • IT人应当知道的10个行业小内幕 beijingjava 工作互联网
    10. 虽然IT业的薪酬比其他很多行业要好，但有公司因此视你为其“佣人”。 　　尽管IT人士的薪水没有互联网泡沫之前要好，但和其他行业人士比较，IT人的薪资还算好点。在接下的几十年中，科技在商业和社会发展中所占分量会一直增加，所以我们完全有理由相信，IT专业人才的需求量也不会减少。 　　然而，正因为IT人士的薪水普遍较高，所以有些公司认为给了你这么多钱，就把你看成是公司的“佣人”，拥有你的支配
  • java 实现自定义链表 CrazyMizzz java数据结构
    1.链表结构   链表是链式的结构 2.链表的组成    链表是由头节点，中间节点和尾节点组成    节点是由两个部分组成：       1.数据域       2.引用域 3.链表的实现 &nbs
  • web项目发布到服务器后图片过一会儿消失 麦田的设计者 struts2上传图片永久保存
      作为一名学习了android和j2ee的程序员，我们必须要意识到，客服端和服务器端的交互是很有必要的，比如你用eclipse写了一个web工程，并且发布到了服务器（tomcat）上，这时你在webapps目录下看到了你发布的web工程，你可以打开电脑的浏览器输入http://localhost:8080/工程/路径访问里面的资源。但是，有时你会突然的发现之前用struts2上传的图片
  • CodeIgniter框架Cart类 name 不能设置中文的解决方法 IT独行者 CodeIgniterCart框架　
    今天试用了一下CodeIgniter的Cart类时遇到了个小问题，发现当name的值为中文时，就写入不了session。在这里特别提醒一下。 在CI手册里也有说明，如下： $data = array( 'id' => 'sku_123ABC', 'qty' => 1, '
  • linux回收站 _wy_ linux回收站
    今天一不小心在ubuntu下把一个文件移动到了回收站，我并不想删，手误了。我急忙到Nautilus下的回收站中准备恢复它，但是里面居然什么都没有。     后来我发现这是由于我删文件的地方不在HOME所在的分区，而是在另一个独立的Linux分区下，这是我专门用于开发的分区。而我删除的东东在分区根目录下的.Trash-1000/file目录下，相关的删除信息（删除时间和文件所在
  • jquery回到页面顶端 知了ing htmljquerycss
    html代码： <h1 id="anchor">页面标题</h1> <div id="container">页面内容</div> <p><a href="#anchor" class="topLink">回到顶端</a><
  • B树、B-树、B+树、B*树 矮蛋蛋 B树
    原文地址： http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html B树        即二叉搜索树：        1.所有非叶子结点至多拥有两个儿子（Left和Right）； &nb
  • 数据库连接池 alafqq 数据库连接池
    http://www.cnblogs.com/xdp-gacl/p/4002804.html @Anthor:孤傲苍狼 数据库连接池 用MySQLv5版本的数据库驱动没有问题，使用MySQLv6和Oracle的数据库驱动时候报如下错误： java.lang.ClassCastException: $Proxy0 cannot be cast to java.sql.Connec
  • java泛型 百合不是茶 java泛型
    泛型 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，任意化的缺点就是要实行强制转换，这种强制转换可能会带来不安全的隐患   泛型的特点：消除强制转换 确保类型安全 向后兼容   简单泛型的定义：      泛型：就是在类中将其模糊化，在创建对象的时候再具体定义 class fan
  • javascript闭包[两个小测试例子] bijian1013 JavaScriptJavaScript
    一.程序一 <script> var name = "The Window"; var Object_a = { 　　name : "My Object", 　　getNameFunc : function(){ var that = this; 　　　　return function(){ 　　　　
  • 探索JUnit4扩展：假设机制（Assumption） bijian1013 javaAssumptionJUnit单元测试
    一.假设机制（Assumption）概述        理想情况下，写测试用例的开发人员可以明确的知道所有导致他们所写的测试用例不通过的地方，但是有的时候，这些导致测试用例不通过的地方并不是很容易的被发现，可能隐藏得很深，从而导致开发人员在写测试用例时很难预测到这些因素，而且往往这些因素并不是开发人员当初设计测试用例时真正目的，
  • 【Gson四】范型POJO的反序列化 bit1129 POJO
    在下面这个例子中，POJO(Data类)是一个范型类，在Tests中，指定范型类为PieceData，POJO初始化完成后，通过 String str = new Gson().toJson(data); 得到范型化的POJO序列化得到的JSON串，然后将这个JSON串反序列化为POJO   import com.google.gson.Gson; import java.
  • 【Spark八十五】Spark Streaming分析结果落地到MySQL bit1129 Stream
    几点总结： 1. DStream.foreachRDD是一个Output Operation，类似于RDD的action，会触发Job的提交。DStream.foreachRDD是数据落地很常用的方法 2. 获取MySQL Connection的操作应该放在foreachRDD的参数（是一个RDD[T]=>Unit的函数类型)，这样，当foreachRDD方法在每个Worker上执行时，
  • NGINX + LUA实现复杂的控制 ronin47 nginx lua
    安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。 这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
  • java-递归判断数组是否升序 bylijinnan java
    public class IsAccendListRecursive { /*递归判断数组是否升序 * if a Integer array is ascending,return true * use recursion */ public static void main(String[] args){ IsAccendListRecursiv
  • Netty源码学习-DefaultChannelPipeline2 bylijinnan javanetty
    Netty3的API http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/ChannelPipeline.html 里面提到ChannelPipeline的一个“pitfall”： 如果ChannelPipeline只有一个handler（假设为handlerA）且希望用另一handler（假设为handlerB） 来
  • Java工具之JPS chinrui java
    JPS使用     熟悉Linux的朋友们都知道，Linux下有一个常用的命令叫做ps（Process Status)，是用来查看Linux环境下进程信息的。同样的，在Java Virtual Machine里面也提供了类似的工具供广大Java开发人员使用，它就是jps（Java Process Status)，它可以用来
  • window.print分页打印 ctrain window
    function init() { var tt = document.getElementById("tt"); var childNodes = tt.childNodes[0].childNodes; var level = 0; for (var i = 0; i < childNodes.length; i++) {
  • 安装hadoop时 执行jps命令Error occurred during initialization of VM daizj jdkhadoopjps
    在安装hadoop时，执行JPS出现下面错误   [slave16][email protected]:/tmp/hsperfdata_hdfs# jps Error occurred during initialization of VM java.lang.Error: Properties init: Could not determine current working
  • PHP开发大型项目的一点经验 dcj3sjt126com PHP重构
    一、变量 最好是把所有的变量存储在一个数组中，这样在程序的开发中可以带来很多的方便，特别是当程序很大的时候。变量的命名就当适合自己的习惯，不管是用拼音还是英语，至少应当有一定的意义，以便适合记忆。变量的命名尽量规范化，不要与PHP中的关键字相冲突。 二、函数 PHP自带了很多函数，这给我们程序的编写带来了很多的方便。当然，在大型程序中我们往往自己要定义许多个函数，几十
  • android笔记之--向网络发送GET/POST请求参数 dcj3sjt126com android
    使用GET方法发送请求 private static boolean sendGETRequest (String path, Map<String, String> params) throws Exception{ //发送地http://192.168.100.91:8080/videoServi
  • linux复习笔记 之bash shell (3) 通配符 eksliang linux 通配符linux通配符
    转载请出自出处： http://eksliang.iteye.com/blog/2104387 在bash的操作环境中有一个非常有用的功能，那就是通配符。 下面列出一些常用的通配符，如下表所示 符号 意义 * 万用字符，代表0个到无穷个任意字符 ? 万用字符，代表一定有一个任意字符 [] 代表一定有一个在中括号内的字符。例如：[abcd]代表一定有一个字符，可能是a、b、c
  • Android关于短信加密 gqdy365 android
    关于Android短信加密功能，我初步了解的如下（只在Android应用层试验）：     1、因为Android有短信收发接口，可以调用接口完成短信收发；         发送过程：APP（基于短信应用修改）接受用户输入号码、内容——>APP对短信内容加密——>调用短信发送方法Sm
  • asp.net在网站根目录下创建文件夹 hvt .netC#hovertreeasp.netWeb Forms
    假设要在asp.net网站的根目录下建立文件夹hovertree,C#代码如下： string m_keleyiFolderName = Server.MapPath("/hovertree"); if (Directory.Exists(m_keleyiFolderName)) { //文件夹已经存在 return; } else { try { D
  • 一个合格的程序员应该读过哪些书 justjavac 程序员书籍
    编者按：2008年8月4日，StackOverflow 网友 Bert F 发帖提问：哪本最具影响力的书，是每个程序员都应该读的？ “如果能时光倒流，回到过去，作为一个开发人员，你可以告诉自己在职业生涯初期应该读一本， 你会选择哪本书呢？我希望这个书单列表内容丰富，可以涵盖很多东西。” 很多程序员响应，他们在推荐时也写下自己的评语。 以前就有国内网友介绍这个程序员书单，不过都是推荐数
  • 单实例实践 跑龙套_az 单例
       1、内部类 public class Singleton { private static class SingletonHolder { public static Singleton singleton = new Singleton(); } public Singleton getRes
  • PO VO BEAN 理解 q137681467 VODTOpo
    PO：      全称是 persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。 好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。     BO：     全称是 business object:业务对象 主要作用是把业务逻辑封装为一个对象。这个对
  • 战胜惰性，暗自努力 金笛子 努力
    偶然看到一句很贴近生活的话：“别人都在你看不到的地方暗自努力，在你看得到的地方，他们也和你一样显得吊儿郎当，和你一样会抱怨，而只有你自己相信这些都是真的，最后也只有你一人继续不思进取。”很多句子总在不经意中就会戳中一部分人的软肋，我想我们每个人的周围总是有那么些表现得“吊儿郎当”的存在，是否你就真的相信他们如此不思进取，而开始放松了对自己的要求随波逐流呢？ 我有个朋友是搞技术的，平时嘻嘻哈哈，以
  • NDK/JNI二维数组多维数组传递 wenzongliang 二维数组jniNDK
    多维数组和对象数组一样处理，例如二维数组里的每个元素还是一个数组 用jArray表示，直到数组变为一维的，且里面元素为基本类型，去获得一维数组指针。给大家提供个例子。已经测试通过。 Java_cn_wzl_FiveChessView_checkWin( JNIEnv* env,jobject thiz,jobjectArray qizidata) { jint i,j; int s
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他