炫酷小辉

十次方项目笔记

项目笔记

1.parent父类pom文件依赖控制


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>com.tensquaregroupId>
    <artifactId>tensquare-parentartifactId>
    <packaging>pompackaging>
    <version>1.0-SNAPSHOTversion>
    <description>十次方项目description>
    <modules>
        <module>tensquare-eurekamodule>
        <module>tensquare-gatewaymodule>
        <module>tensquare-commonmodule>
        <module>tensquare-basemodule>
    modules>

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

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
        <java.version>1.8java.version>
        <spring-cloud.version>Greenwich.SR1spring-cloud.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>

    <dependencyManagement>
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.cloudgroupId>
                <artifactId>spring-cloud-dependenciesartifactId>
                <version>${spring-cloud.version}version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
    dependencyManagement>


project>

2.tensquare-eureka 注册中心

依赖


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>tensquare-parentartifactId>
        <groupId>com.tensquaregroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <description>注册中心Eurekadescription>

    <modelVersion>4.0.0modelVersion>

    <groupId>com.tensquaregroupId>

    <artifactId>tensquare-eurekaartifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
        dependency>
    dependencies>
project>

package com.tensquare.eureka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * 注册中心的启动类
 * @author Johnny.Chen
 *
 */
@SpringBootApplication
@EnableEurekaServer//启用注册中心
public class EurekaServerApplication {

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

}

application.yml配置文件

server:
  port: 10086 #端口号
spring:
  application:
    name: eureka-server #微服务id
eureka:
  client: #客户端：自己不用注册自己
    fetch-registry: false
    register-with-eureka: false
    service-url:
      defaultZone: http://localhost:10086/eureka
  server: #服务端：配置
    enable-self-preservation: false # 关闭自我保护
    eviction-interval-timer-in-ms: 5000 # 每隔5秒进行一次服务列表清理

3.tensquare-gateway

依赖


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>tensquare-parentartifactId>
        <groupId>com.tensquaregroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <groupId>com.tensquaregroupId>
    <artifactId>tensquare-gatewayartifactId>

    
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-gatewayartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
        dependency>

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redis-reactiveartifactId>
            <version>2.1.3.RELEASEversion>
        dependency>
    dependencies>
project>

注意：不要引入spring-boot-starter-web包，会导致Gateway启动抛出异常，错误如下。因为Spring Cloud Gateway 是使用 netty+webflux实现，webflux与web是冲突的

Consider defining a bean of type 'org.springframework.http.codec.ServerCodecConfigurer' in your configuration.

启动类

package com.tensquare.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@SpringBootApplication
@EnableEurekaClient
public class GatewayApplication {

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


    /***
     * IP限流
     * @return
     */
    @Bean(name="ipKeyResolver")
    public KeyResolver userKeyResolver() {
        return new KeyResolver() {
            @Override
            public Mono<String> resolve(ServerWebExchange exchange) {
                //获取远程客户端IP
                String hostName = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();
                System.out.println("hostName:"+hostName);
                return Mono.just(hostName);
            }
        };
    }
}

application.yml配置

spring:
  application:
    name: gateway-web
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]': # 匹配所有请求
            allowedOrigins: "*" #跨域处理 允许所有的域
            allowedMethods: # 支持的方法
              - GET
              - POST
              - PUT
              - DELETE

      routes:
        - id: base_route
          #uri: http://localhost:9001
          uri: lb://tensquare-base
          predicates:
            #- Host=cloud.itheima.com**
            - Path=/base/**
          filters:
            #- PrefixPath=/base
            - StripPrefix=1
            #请求数限流 名字不能随便写 ，使用默认的facatory
            - name: RequestRateLimiter
              args:
                key-resolver: "#{@ipKeyResolver}"
                redis-rate-limiter.replenishRate: 1
                redis-rate-limiter.burstCapacity: 1


  redis:
    host: 192.168.139.128
    port: 6379


server:
  port: 8888
#eureka客户端
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:10086/eureka
  instance:
    ip-address: 127.0.0.1
    instance-id: ${eureka.instance.ip-address}:${server.port}
    lease-renewal-interval-in-seconds: 5 #开发阶段改小


#熔断器配置
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMillisecond: 10000 # 熔断超时时长：10000ms


management:
  endpoint:
    gateway:
      enabled: true
    web:
      exposure:
        include: true

网关统一解决跨域问题

package com.tensquare.gateway.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
import org.springframework.web.util.pattern.PathPatternParser;

@Configuration
public class CorsConfig {
    @Bean
    public CorsWebFilter corsFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedMethod("*");
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**", config);

        return new CorsWebFilter(source);
    }
}

4.tensquare-comom


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>tensquare-parentartifactId>
        <groupId>com.tensquaregroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <groupId>com.tensquaregroupId>
    <artifactId>tensquare-commonartifactId>
    <dependencies>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>
        <dependency>
            <groupId>io.jsonwebtokengroupId>
            <artifactId>jjwtartifactId>
            <version>0.6.0version>
        dependency>

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

project>

pageResult类

package entity;

import java.util.List;

public class PageResult<T> {

	private Long total;
	private List<T> rows;
	
	public PageResult(Long total, List<T> rows) {
		super();
		this.total = total;
		this.rows = rows;
	}
	
	public Long getTotal() {
		return total;
	}
	public void setTotal(Long total) {
		this.total = total;
	}
	public List<T> getRows() {
		return rows;
	}
	public void setRows(List<T> rows) {
		this.rows = rows;
	}
	
	
	
}

Result类

package entity;

/**
 * 响应实体
 * @author Johnny.Chen
 *
 */
public class Result {

	private Integer code;
	private Boolean flag;
	private String message;
	private Object data;

	/**
	 * 无参构造器
	 */
	public Result() {
		super();
	}

	/**
	 * 有参的构造器
	 * @param flag
	 * @param code
	 * @param message
	 */
	public Result(boolean flag, int code, String message) {
		super();
		this.code = code;
		this.flag = flag;
		this.message = message;
	}

	/**
	 * 全参的构造器
	 * @param code
	 * @param flag
	 * @param message
	 * @param data
	 */
	public Result(boolean flag, int code, String message, Object data) {
		super();
		this.code = code;
		this.flag = flag;
		this.message = message;
		this.data = data;
	}


	public int getCode() {
		return code;
	}

	public void setCode(int code) {
		this.code = code;
	}

	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}

	public String getMessage() {
		return message;
	}

	public void setMessage(String message) {
		this.message = message;
	}

	public Object getData() {
		return data;
	}

	public void setData(Object data) {
		this.data = data;
	}

}

状态码类StatusCode

package entity;

/**
 *  状态
 */
public class StatusCode {

    public static  final int OK=20000;//成功
    public static  final int ERROR=20001;//失败
    public static  final int LONGINERROR=20002;//用户名或者密码错误
    public static  final int ACCESSERROR=20003;//权限不足
    public static  final int REMOTEERROR=20004;//远程调用失败
    public static  final int REPERROR=20005;//重复操作


}

IdWorker id自动生成器(雪花算法)

package utils;

import java.lang.management.ManagementFactory;
import java.net.InetAddress;
import java.net.NetworkInterface;

/**
 * 名称：IdWorker.java
 * 描述：分布式自增长ID
 *  *     Twitter的 Snowflake　JAVA实现方案
 * 
 * 核心代码为其IdWorker这个类实现，其原理结构如下，我分别用一个0表示一位，用—分割开部分的作用：
 * 1||0---0000000000 0000000000 0000000000 0000000000 0 --- 00000 ---00000 ---000000000000
 * 在上面的字符串中，第一位为未使用（实际上也可作为long的符号位），接下来的41位为毫秒级时间，
 * 然后5位datacenter标识位，5位机器ID（并不算标识符，实际是为线程标识），
 * 然后12位该毫秒内的当前毫秒内的计数，加起来刚好64位，为一个Long型。
 * 这样的好处是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞（由datacenter和机器ID作区分），
 * 并且效率较高，经测试，snowflake每秒能够产生26万ID左右，完全满足需要。
 * 
 * 64位ID (42(毫秒)+5(机器ID)+5(业务编码)+12(重复累加))
 *
 * @author Polim
 */
public class IdWorker {
    // 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）
    private final static long twepoch = 1288834974657L;
    // 机器标识位数
    private final static long workerIdBits = 5L;
    // 数据中心标识位数
    private final static long datacenterIdBits = 5L;
    // 机器ID最大值
    private final static long maxWorkerId = -1L ^ (-1L << workerIdBits);
    // 数据中心ID最大值
    private final static long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    // 毫秒内自增位
    private final static long sequenceBits = 12L;
    // 机器ID偏左移12位
    private final static long workerIdShift = sequenceBits;
    // 数据中心ID左移17位
    private final static long datacenterIdShift = sequenceBits + workerIdBits;
    // 时间毫秒左移22位
    private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

    private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
    /* 上次生产id时间戳 */
    private static long lastTimestamp = -1L;
    // 0，并发控制
    private long sequence = 0L;

    private final long workerId;
    // 数据标识id部分
    private final long datacenterId;

    public IdWorker(){
        this.datacenterId = getDatacenterId(maxDatacenterId);
        this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);
    }
    /**
     * @param workerId
     *            工作机器ID
     * @param datacenterId
     *            序列号
     */
    public IdWorker(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }
    /**
     * 获取下一个ID
     *
     * @return
     */
    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }

        if (lastTimestamp == timestamp) {
            // 当前毫秒内，则+1
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                // 当前毫秒内计数满了，则等待下一秒
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = timestamp;
        // ID偏移组合生成最终的ID，并返回ID
        long nextId = ((timestamp - twepoch) << timestampLeftShift)
                | (datacenterId << datacenterIdShift)
                | (workerId << workerIdShift) | sequence;

        return nextId;
    }

    private long tilNextMillis(final long lastTimestamp) {
        long timestamp = this.timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = this.timeGen();
        }
        return timestamp;
    }

    private long timeGen() {
        return System.currentTimeMillis();
    }

    /**
     * 

     * 获取 maxWorkerId
     * 
     */
    protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) {
        StringBuffer mpid = new StringBuffer();
        mpid.append(datacenterId);
        String name = ManagementFactory.getRuntimeMXBean().getName();
        if (!name.isEmpty()) {
            /*
             * GET jvmPid
             */
            mpid.append(name.split("@")[0]);
        }
        /*
         * MAC + PID 的 hashcode 获取16个低位
         */
        return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
    }

    /**
     * 
     * 数据标识id部分
     * 
     */
    protected static long getDatacenterId(long maxDatacenterId) {
        long id = 0L;
        try {
            InetAddress ip = InetAddress.getLocalHost();
            NetworkInterface network = NetworkInterface.getByInetAddress(ip);
            if (network == null) {
                id = 1L;
            } else {
                byte[] mac = network.getHardwareAddress();
                id = ((0x000000FF & (long) mac[mac.length - 1])
                        | (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
                id = id % (maxDatacenterId + 1);
            }
        } catch (Exception e) {
            System.out.println(" getDatacenterId: " + e.getMessage());
        }
        return id;
    }


    public static void main(String[] args) {
        //推特  26万个不重复的ID
        IdWorker idWorker = new IdWorker(0,0);
        for (int i = 0; i <2600 ; i++) {
            System.out.println(idWorker.nextId());
        }
    }

}

5.tensquare-base 基础微服务

依赖


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>tensquare-parentartifactId>
        <groupId>com.tensquaregroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <groupId>com.tensquaregroupId>
    <artifactId>tensquare-baseartifactId>
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-jpaartifactId>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>
        
        <dependency>
            <groupId>com.tensquaregroupId>
            <artifactId>tensquare-commonartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>


    dependencies>

project>

application.yml配置文件

server:
  port: 9001
spring:
  application:
    name: tensquare-base #微服务名称，不能有下划线，在SpringCloud中使用到
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.139.128:3306/tensquare_base?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: 123456
  jpa:
    show-sql: true
    generate-ddl: false
    database: mysql
#Eureka注册中心
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
  instance:
    instance-id: ${spring.application.name}:${server.port}
    ip-address: 127.0.0.1
    prefer-ip-address: true

日志的xml文件



<configuration>
    
    <property name="LOG_HOME" value="d:/logs"/>

    
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%npattern>
            <charset>utf8charset>
        encoder>
    appender>

    
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            
            <fileNamePattern>${LOG_HOME}/tensquare-base.%d{yyyy-MM-dd}.logfileNamePattern>
        rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%npattern>
        encoder>
    appender>

    
    <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
        
        <discardingThreshold>0discardingThreshold>
        
        <queueSize>512queueSize>
        
        <appender-ref ref="FILE"/>
    appender>


    <logger name="org.apache.ibatis.cache.decorators.LoggingCache" level="DEBUG" additivity="false">
        <appender-ref ref="CONSOLE"/>
    logger>
    <logger name="org.springframework.boot" level="DEBUG"/>
    <root level="info">
        
        <appender-ref ref="FILE"/>
        <appender-ref ref="CONSOLE"/>
    root>
configuration>

结构

pojo

package com.tensquare.base.pojo;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;

@Entity
@Table(name="tb_label")
@Data
public class Label implements Serializable {

    @Id
    private Long id;
    private String labelname; //标签名称
    private String state; //状态
    private Long count; //使用数量
    private String recommend; //是否推荐
    @Column(name ="fans") //默认加上了和属性名一样  
    private Long fans; //粉丝数
    
     @Transient   //忽略属性
    private String createUser;//创建时间
}

dao

package com.tensquare.base.pojo;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;

@Entity
@Table(name="tb_label")
@Data
public class Label implements Serializable {

    @Id
    private Long id;
    private String labelname; //标签名称
    private String state; //状态
    private Long count; //使用数量
    private String recommend; //是否推荐
    private Long fans; //粉丝数
}

service

package com.tensquare.base.service;


import com.tensquare.base.dao.LabelDao;
import com.tensquare.base.pojo.Label;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import utils.IdWorker;

import java.util.List;


@Service
public class LabelService {

    @Autowired
    private LabelDao labelDao;

    @Autowired
    private IdWorker idWorker;

    //查询所有
    public List<Label> findAll(){
        return labelDao.findAll();
    }

    //根据id查询一个
    public Label findById(Long id) {
        return labelDao.findById(id).get();
    }

    //新增一个
    public void add(Label label) {
        //指定id
        label.setId(idWorker.nextId());
        labelDao.save(label);
    }

    //修改一个
    public void update(Label label) {
        labelDao.save(label);
    }

    //删除
    public void deleteById(Long id) {
        labelDao.deleteById(id);
    }
}

controller

package com.tensquare.base.controller;

import com.tensquare.base.pojo.Label;
import com.tensquare.base.service.LabelService;
import entity.Result;
import entity.StatusCode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/label")
public class LabelController {

    @Autowired
    private LabelService labelService;

    //查询所有
    @RequestMapping(method = RequestMethod.GET)
    public Result findAll(){
        return new Result(true, StatusCode.OK,"查询成功",labelService.findAll());
    }

    //查询一个
    @RequestMapping(value="/{id}")
    public Result findById(@PathVariable Long id){
        return new Result(true, StatusCode.OK, "查询成功", labelService.findById(id));
    }

    //新增一个
    @RequestMapping(method = RequestMethod.POST)
    public Result add(@RequestBody Label label){
        labelService.add(label);
        return new Result(true, StatusCode.OK, "添加成功");
    }

    //更新一个
    @RequestMapping(value="/{id}",method = RequestMethod.PUT)
    public Result update(@PathVariable Long id, @RequestBody Label label){
        label.setId(id);//以url中的id为主
        labelService.update(label);
        return new Result(true, StatusCode.OK, "修改成功");
    }

    //删除一个
    @RequestMapping(value="/{id}",method = RequestMethod.DELETE)
    public Result deleteById(@PathVariable  Long id){
        labelService.deleteById(id);
        return new Result(true, StatusCode.OK, "删除成功");
    }

}

启动类

package com.tensquare.base;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import utils.IdWorker;
/**
 * @author thh
 * @功能描述 基础微服务
 * @date 2020/01/25 19:21
 * @Param
 * @return
 **/
@SpringBootApplication
@EnableDiscoveryClient
public class BaseApplication {

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

	/**
	 * 把idwork给Spring容器管理
	 */
	@Bean
	public IdWorker idWorker() {
		return new IdWorker();
	}

}

统一异常处理

package com.tensquare.base.controller;

import entity.Result;
import entity.StatusCode;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 全局异常
 */
@ControllerAdvice
public class BaseExceptionHandler {

    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Result error1(Exception e){
        return new Result(false, StatusCode.ERROR,"基础微服务异常："+e.getMessage());
    }

}

拦截器

package com.tensquare.base.interceptor;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author thh
 * 拦截器  （项目请求数据存入日志）  可以在本类中写入自己定义的逻辑拦截
 */
@Component
public class CustomInterceptor extends HandlerInterceptorAdapter {
    //记录器
    private static final Logger LOGGER = LoggerFactory.getLogger(Exception.class);


    /**
     * @author thh
     * @功能描述 拦截器
     * @date 2020/01/25 21:51
     * @Param [request, response, handler]
     * @return boolean
     **/
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        //打印请求
        String method = request.getMethod();
        String uri = request.getRequestURI();//返回请求行中的资源名称
        String url = request.getRequestURL().toString();//获得客户端发送请求的完整url
        String ip = request.getRemoteAddr();//返回发出请求的IP地址
        String params = request.getQueryString();//返回请求行中的参数部分
        String id = null;
        LOGGER.info(String.format("%n请求url: %s%n请求方式: %s%nuri: %s%n请求ip: %s%n请求参数: %s%n请求结果: %s", url, method, uri, ip, params, "通过"));
        return  true;
    }



}

mvc配置文件

package com.tensquare.base.interceptor;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
@EnableWebMvc
public class CustomWebMvcConfigurerAdapter implements WebMvcConfigurer {


    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new CustomInterceptor()).addPathPatterns("/**");  //对来自/** 这个链接来的请求进行拦截
    }
}

6.JAP条件查询以及JAP分页查询

1）内置的接口的方法查询

2）JPQL查询： @Query(value=“JPQL语句”) 如果是更新操作加一个注解@Modifying

3）SQL查询：@Query(value=“sql语句”,nativeQuery=true)

4）方法命名规则查询： findBy开头…

5）动态查询：查询条件不固定，Specification

controller

	/**
	 * 分页条件查询
	 * @param page 当前页
	 * @param size 页大小
	 * @param label 查询条件
	 * @return
	 */
	@PostMapping("/search/{page}/{size}")
	public Result search(@PathVariable("page") int page, @PathVariable("size") int size,@RequestBody Label label) {
		//分页查询
		Page<Label> pageBean = labelService.search(page,size,label);
		//当前页数据
		List<Label> rows = pageBean.getContent();
		//总记录数
		long totalElements = pageBean.getTotalElements();
		//返回分页结果集
		return new Result(true,StatusCode.OK,"分页条件查询成功",new PageResult<Label>(totalElements, rows));
	}

service

	/**
	 * 分页条件查询
	 * @param page
	 * @param size
	 * @param label
	 * @return
	 */
	public Page<Label> search(int page, int size, Label label) {
		//拼接查询条件
		//Specification spec = createSpec(label);
		//分页条件
		//PageRequest pageable = PageRequest.of(page-1, size);
		//分页查询
		return labelDao.findAll(createSpec(label), PageRequest.of(page-1, size));
	}
	
	private Specification<Label> createSpec(Label label) {
		return new Specification<Label>() {
			/**
			 * root： 用于获取实体类的属性
			 * query: 查询顶层接口
			 * cb: 动态构建查询条件
			 */
			@Override
			public Predicate toPredicate(Root<Label> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				
				List<Predicate> preList = new ArrayList<Predicate>();
				
				//根据标签名称模糊查询
				if(label.getLabelname()!=null && !"".equals(label.getLabelname())) {
					//获取类型
					Path<String> path = root.get("labelname");
					//构建查询条件
					Predicate like = cb.like(path, "%"+label.getLabelname()+"%");
					//存入查询条件
					preList.add(like);
				}
				
				//根据状态精确查询
				if(label.getState()!=null && !"".equals(label.getState())) {
					//获取类型
					Path<String> path = root.get("state");
					//构建查询条件
					Predicate e = cb.equal(path, label.getState());
					//存入查询条件
					preList.add(e);
				}
				//===========================
				
				
				//实例化查询的条件的数组
				Predicate[] predicate =  new Predicate[preList.size()];
				
				//把list中的Predicate 转存入数组中
				predicate = preList.toArray(predicate);
				
				//执行查询
				return cb.and(predicate);
			}
		};
	}

小结

JPASpecificationExecutor接口的使用

重点看下base模块中的service类就可以了

findAll(Specification spec):  组合条件查询
Page<> findAll(Specification spec, Pageable pageable)： 组合条件+分页查询

7.代码生成器的使用

直接复制到项目的parent路径下导入

测试成功！

8.tensquare-recruit 招聘微服务

目标：学习jap的mapper的命名法

招聘微服务：热门企业列表

核心代码：

controller

/**
 * 热门企业
 */
@RequestMapping(value = "/search/hotlist",method = RequestMethod.GET)
public Result hotlist(){
   List<Enterprise> list = enterpriseService.hotlist();
   return new Result(true,StatusCode.OK,"查询成功",list);
}

service

/**
 * 热门企业
 */
public List<Enterprise> hotlist(){
   /**
    * 查询ishot=1的企业列表
    *  命名查询实现
    */
   return enterpriseDao.findTop9ByIshot("1");
}

/**
 * 热门企业
 */
public List<Enterprise> findTop9ByIshot(String ishot);

小结：

使用SpringDataJPA如何查询ishot为1的数据？
声明方法：findByIshot("1")

招聘微服务：推荐职位和最新职位

关键步骤和核心代码

1）Controller

/**
 * 推荐职位
 */
@RequestMapping(value = "/search/recommend",method = RequestMethod.GET)
public Result recommend(){
   List<Recruit> list = recruitService.recommend();
   return new Result(true,StatusCode.OK,"查询成功",list);
}

/**
 * 最新职位
 */
@RequestMapping(value = "/search/newlist",method = RequestMethod.GET)
public Result newlist(){
   List<Recruit> list = recruitService.newlist();
   return new Result(true,StatusCode.OK,"查询成功",list);
}

2）Service

/**
 * 推荐职位
 */
public List<Recruit> recommend(){
   /**
    *  state为2 : findByState("2")
       按照createtime倒序: OrderByCreatetimeDesc
       取前面4条:  Top4
    */
   return recruitDao.findTop4ByStateOrderByCreatetimeDesc("2");
}

/**
 * 最新职位
 */
public List<Recruit> newlist(){
   /**
    *   state不为0 : findByStateNot("0")
        按照createtime倒序: OrderByCreatetimeDesc
        取前面12条: Top12
    */
   return recruitDao.findTop12ByStateNotOrderByCreatetimeDesc("0");
}

/**
 * 推荐职位
 */
public List<Recruit> findTop4ByStateOrderByCreatetimeDesc(String state);

/**
 * 最新职位
 */
public List<Recruit> findTop12ByStateNotOrderByCreatetimeDesc(String state);

小结

使用SpringDataJPA如何取出前几条数据？

Top4: 前4条

OrderByXXXDesc: 排序

总结Spring Data JPA命名查询：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x3B89nts-1581138771879)(十次方笔记.assets/.png)]

9.tensquare-qa：需求分析及代码生成

目标

明确问答微服务的需求

最新问答：根据标签id查询问答（多表查询），分页，且按照replytime倒序显示

热门问答：根据标签id查询问答（多表查询），分页，且按照reply倒序显示

等待问答：根据标签id查询问答（多表查询），分页，且查询reply为0的问答

代码生成器生成问答微服务

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n5OpJ0Y9-1581138771879)(十次方笔记.assets/1580026707361.png)]

小结

请问SpirngDataJPA如何实现多表查询？

@Query注解来完成

Query(value=“JPQL语句”)： JPQL中出现类名或属性名称

问答微服务：最新问答-Controller和Service和Dao

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wB1R73br-1581138771879)(十次方笔记.assets/1580028036369.png)]

1）Controller

	@RequestMapping(value="/newlist/{labelid}/{page}/{size}",method= RequestMethod.GET)
	public Result newlist(@PathVariable String labelid ,@PathVariable int page, @PathVariable int size){
		//查询没有标签id的内容
		if("0".equals(labelid)){
			Page<Problem> pageBean =    problemService.findAll(page,size);
			return new Result(true,StatusCode.OK,"查询成功",new PageResult<Problem>(pageBean.getTotalElements(),pageBean.getContent()));
		}
		//多表查询
		Page<Problem> pageBean2 = problemService.newlist(labelid,page,size);
		return new Result(true,StatusCode.OK,"查询成功",new PageResult<Problem>(pageBean2.getTotalElements(),pageBean2.getContent()));
	}

2）Service

/**
	 * 分页查询
	 * @param page
	 * @param size
	 * @return
	 */
	public Page<Problem> findAll(int page, int size) {
		return problemDao.findAll(PageRequest.of(page-1,size));
	}

	//多表查询:  分页条件永远放到参数的最后
	public Page<Problem> newlist(String labelid, int page, int size) {
		return problemDao.newlist(labelid, PageRequest.of(page-1,size));
	}

3)Dao

package com.tensquare.qa.dao;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import com.tensquare.qa.pojo.Problem;
import org.springframework.data.jpa.repository.Query;

/**
 * 数据访问接口
 * @author Administrator
 *
 */
public interface ProblemDao extends JpaRepository<Problem,String>,JpaSpecificationExecutor<Problem>{


    /**
     * 最新问答列表
     * @param labelid
     * @param of   : 必须是分页条件的接口，不能写实现类
     * @return
     */
    @Query(value="SELECT * FROM tb_problem,tb_pl WHERE id = problemid AND labelid=?1 ORDER BY replytime DESC",nativeQuery = true)
    public Page<Problem> newlist(String labelid, Pageable of);
}

小结

使用SpringDataJPA如何实现分页查询？

无论在JpaSpecification，命名查询，还是@Query注解都统一使用：

Pageable接口实现： PageRequest.of(page-1,size)

热门问答和等待问答

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fMR9HrE2-1581138771880)(十次方笔记.assets/1580030458708.png)]

1）Controller

	// 查询热门问答
    @RequestMapping(value="/hotlist/{labelid}/{page}/{size}",method= RequestMethod.GET)
    public Result hotlist(@PathVariable String labelid ,@PathVariable Integer page ,@PathVariable Integer size){
        Page<Problem> pageBean = problemService.hotlist(labelid,page,size);
        return new Result(true,StatusCode.OK,"查询热门问答成功",new PageResult<Problem>(pageBean.getTotalElements(),pageBean.getContent()));
    }

    //查询等待问
    @RequestMapping(value="/waitlist/{labelid}/{page}/{size}",method= RequestMethod.GET)
    public Result waitlist(@PathVariable String labelid ,@PathVariable Integer page ,@PathVariable Integer size){
        Page<Problem> pageBean = problemService.waitlist(labelid,page,size);
        return new Result(true,StatusCode.OK,"查询等待问答成功",new PageResult<Problem>(pageBean.getTotalElements(),pageBean.getContent()));
    }

2）Service

public Page<Problem> hotlist(String labelid, Integer page, Integer size) {
		return problemDao.hotlist(labelid,PageRequest.of(page-1,size));
	}

	public Page<Problem> waitlist(String labelid, Integer page, Integer size) {
		return problemDao.waitlist(labelid,PageRequest.of(page-1,size));
	}

3）Dao

// 热门问答
    @Query(value="SELECT * FROM tb_problem,tb_pl WHERE id = problemid AND labelid = ?1  ORDER BY reply DESC",nativeQuery = true)
    public Page<Problem> hotlist(String labelid, Pageable of);

    //等待回答
    @Query(value="SELECT * FROM tb_problem,tb_pl WHERE id = problemid AND labelid = ?1 AND reply=0 ORDER BY createtime DESC",nativeQuery = true)
    public Page<Problem> waitlist(String labelid, Pageable of);

小结

热门回答和最新回答的需求差别在哪里？

1）最新问答：按照replytime（最新回复时间）倒序显示

热门问答：按照reply （回复数）倒序显示

10.tensquare-article 文章微服务（redis）

用代码生成器生成代码修改端口 gateway增加映射

SpringDataRedis：缓存文章详情 在yml增加redis配置

yml配置

spring:
  redis:
    host: 192.168.139.128
  	port: 6379

依赖

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

在需要使用spring-data-redis的地方注入RedisTemplate对象

@Autowired
private RedisTemplate redisTemplate;

使用SpringDataRedis实现对文章详情的缓存

具体效果是：

1）第一次访问新文章的时候，没有缓存，从mysql数据库查询出来，然后放入redis缓存

2）第n次访问的时候，已经有缓存，直接从redis缓存取出

使用SpringDataRedis清除Redis缓存

使用SpringDataRedis设置缓存过期时间

关键步骤和核心代码

使用SpringDataRedis实现对文章详情的缓存

/**
 * 根据ID查询实体
 * @param id
 * @return
 */
public Article findById(String id) {
   //1.从redis查询是否有该文章的缓存
   Article article = (Article)redisTemplate.opsForValue().get("article_"+id);
   
   if(article==null) {
      //1.1 没有，从数据库查询出来，放入redis缓存
      article = articleDao.findById(id).get();
      
      //放入redis缓存
      redisTemplate.opsForValue().set("article_"+id,article);
   }
   
   //1.2 有，直接返回即可
   return article;
}

使用SpringDataRedis清除Redis缓存

/**
 * 修改
 * @param article
 */
public void update(Article article) {
   articleDao.save(article);
   //清除缓存
   redisTemplate.delete("article_"+article.getId());
}

/**
 * 删除
 * @param id
 */
public void deleteById(String id) {
   articleDao.deleteById(id);
   //清除缓存
   redisTemplate.delete("article_"+id);
}

使用SpringDataRedis设置缓存过期时间

//设置20秒后缓存过期
redisTemplate.opsForValue().set("article_"+id,article,20, TimeUnit.SECONDS);

小结

如何使用SpringDataRedis存入和取出数据？
如何使用SpringDataRedis删除数据？
如何使用SpringDataRedis设置缓存过期时长？

RedisTemplate用法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L6AHNMuj-1581138771881)(十次方笔记.assets/1580033550235.png)]

11.tensquare-gathering 活动微服务

使用SpringCache实现活动详情缓存

具体效果是：

1）第一次访问新活动时候，没有缓存，从mysql数据库查询出来，然后放入springcache缓存

2）第n次访问的时候，已经有缓存，直接从springcache缓存取出

使用SpringCache清除缓存

重点：

Redis 和 SpringCache选择

1）分布式下，可以选择redis ，可以设置过期时间，可以持久化

2）单体系统，可以选择SpringCache，不可以设置过期时间，不可以持久化

虽然说现在是微服务不过还是需要知道如何使用springcache 当成技术点来学习

关键步骤和核心代码

使用SpringCache实现活动详情缓存

1）在启动类开启SpringCache功能

@SpringBootApplication
@EnableCaching // 开启SpringCache功能
public class GatheringApplication {

2）在需要缓存的方法上面加上@Cacheable注解

@Cacheable(value = "gathering",key = "#id")
public Gathering findById(String id) {
   return gatheringDao.findById(id).get();
}

3）可以使用@CacheEvict清除缓存

/**
 * 修改
 * @param gathering
 */
@CacheEvict(value = "gathering",key = "#gathering.id" )
public void update(Gathering gathering) {
   gatheringDao.save(gathering);
}

/**
 * 删除
 * @param id
 */
@CacheEvict(value = "gathering",key = "#id")
public void deleteById(String id) {
   gatheringDao.deleteById(id);
}

12.tensquare_spit吐槽微服务(springdata-mongodb)

关键步骤和核心代码

1）建立吐槽微服务模块

2）导入spring-data-mongodb坐标

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0modelVersion>
	<parent>
		<groupId>com.tensquaregroupId>
		<artifactId>tensquare_parentartifactId>
		<version>1.0-SNAPSHOTversion>
	parent>
	<artifactId>tensquare_spitartifactId>
	<dependencies>
		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-data-mongodbartifactId>
		dependency>
		<dependency>
			<groupId>com.tensquaregroupId>
			<artifactId>tensquare_commonartifactId>
			<version>1.0-SNAPSHOTversion>
		dependency>
		
		<dependency>
			<groupId>org.springframework.cloudgroupId>
			<artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
		dependency>
	dependencies>
project>

3）编写application.yml，连接mongoDB

server:
  port: 9005
spring:
  application:
    name: tensquare-spit
  data:
    mongodb:
      host: 192.168.207.111  # ip或者主机名
      port: 27017 #端口号
      database: spitdb
#Eureka客户端配置
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
  instance:
    lease-renewal-interval-in-seconds: 5 # 每隔5秒发送一次心跳
    lease-expiration-duration-in-seconds: 10 # 10秒不发送就过期
    prefer-ip-address: true
    ip-address: 127.0.0.1
    instance-id: ${spring.application.name}:${server.port}

编写启动类

/**
 * 吐槽微服务
 */
@SpringBootApplication
public class SpitApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpitApplication.class,args);
    }
    
    @Bean
    public IdWorker idWorker(){
        return new IdWorker();
    }
    
}

小结

总结整合SpringDataMongoDB的过程

1）导入spirng-data-mongodb坐标

2）application.yml连接mongodb

吐槽微服务：实现CRUD操作

使用SpringDataMongoDB实现吐槽的CRUD功能

关键步骤和核心代码

1）编写Pojo（*）

/**
 * 吐槽
 */
@Document(collection = "spit") // 映射集合（相当于映射表）
@Data
public class Spit implements Serializable{

    @Id
    private String id;

   // @Field("content")   相当于JPA的@Column
    private String content;
    private Date publishtime;
    private String userid;
    private String nickname;
    private Integer visits;
    private Integer thumbup;
    private Integer share;
    private Integer comment;
    private String state;
    private String parentid;//父id
    
}

2）编写Dao（*）

/**
 * 吐槽dao接口
 * MongoRepository类似于JpaRepository，拥有CRUD方法
 */
public interface SpitDao extends MongoRepository<Spit,String>{
}

3）编写Service

/**
 * 吐槽service
 */
@Service
public class SpitService {

    @Autowired
    private SpitDao spitDao;

    @Autowired
    private IdWorker idWorker;

    /**
     * 查询所有
     */
    public List<Spit> findAll(){
        return spitDao.findAll();
    }

    /**
     * 查询一个
     */
    public Spit findById(String id){
        return spitDao.findById(id).get();
    }


    /**
     * 添加
     */
    public void add(Spit spit){
        //设置id
        spit.setId(idWorker.nextId()+"");
        spitDao.save(spit);
    }

    /**
     * 修改
     */
    public void update(Spit spit){ // spit必须带有数据库存在的id
        spitDao.save(spit);
    }

    /**
     * 删除
     */
    public void delete(String id){
        spitDao.deleteById(id);
    }

}

4）编写Controller

/**
 * 吐槽Controller
 */
@RequestMapping("/spit")
@RestController  // @RestController = @Controller+@ResponseBody
@CrossOrigin //解决前端跨域请求问题
public class SpitController {

    @Autowired
    private SpitService spitService;

    /**
     * 查询所有
     */
    @RequestMapping(method = RequestMethod.GET)
    public Result findAll(){
        return new Result(true, StatusCode.OK,"查询成功",spitService.findAll());
    }

    /**
     * 查询一个
     */
    @RequestMapping(value = "/{id}" ,method = RequestMethod.GET)
    public Result findById(@PathVariable String id){
        return new Result(true,StatusCode.OK,"查询成功",spitService.findById(id));
    }

    /**
     * 添加
     */
    @RequestMapping(method = RequestMethod.POST)
    public Result add(@RequestBody Spit spit){
        spitService.add(spit);
        return new Result(true,StatusCode.OK,"添加成功");
    }

    /**
     * 修改
     */
    @RequestMapping(value = "/{id}",method = RequestMethod.PUT)
    public Result update(@PathVariable String id,@RequestBody Spit spit){
        spit.setId(id);
        spitService.update(spit);
        return new Result(true,StatusCode.OK,"修改成功");
    }

    /**
     * 删除
     */
    @RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
    public Result delete(@PathVariable String id){
        spitService.delete(id);
        return new Result(true,StatusCode.OK,"删除成功");
    }


}

小结

请问如何映射实体与mongoDB集合？

@Document(colletion=“集合名称”)

请问实现CRUD操作，Dao需要继承哪个接口？

MongoRepository

吐槽微服务：根据上级ID查询吐槽数据

目标

（根据吐槽ID查询其下面的评论数据）

评论数据

关键步骤和核心代码

Controller

/**
 * 根据上级ID查询吐槽
 */
@RequestMapping(value = "/comment/{parentid}/{page}/{size}",method = RequestMethod.GET)
public Result findByParentid(@PathVariable String parentid,@PathVariable int page,@PathVariable int size){
    Page<Spit> pageData = spitService.findByParentid(parentid,page,size);
    return new Result(true,StatusCode.OK,"查询成功",new PageResult<>(pageData.getTotalElements(),pageData.getContent()));
}

Service

/**
 * 根据上级ID查询吐槽
 */
public Page<Spit> findByParentid(String parentid,int page,int size){
    /**
     * 使用命名查询+Pageable
     */
    return spitDao.findByParentid(parentid,PageRequest.of(page-1,size));
}

Dao

public Page<Spit> findByParentid(String parentid, Pageable pageable);

小结

请问SpringDataMongoDB可以使用命名查询吗？如何实现分页？

可以使用命名查询！传入Pageable的实现类对象可以实现分页：PageRequest.of(page-1,size)

吐槽微服务：吐槽点赞（第一种方案）

目标

吐槽一次，让吐槽集合中的thumbup字段值+1

关键步骤和核心代码

Controller

/**
 * 吐槽点赞
 */
@RequestMapping(value = "/thumbup/{id}",method = RequestMethod.PUT)
public Result thumbup(@PathVariable String id){
    spitService.thumbup(id);
    return new Result(true,StatusCode.OK,"点赞成功");
}

Service

/**
 * 吐槽点赞（第一种方案）
 */
public void thumbup(String id){
    //1.先查询出整个吐槽对象
    Spit spit = findById(id);
    //2.对点赞数+1
    spit.setThumbup(spit.getThumbup()+1);
    //3.把点赞数写回到表中去
    update(spit);
}

小结

这种方案，需要操作两次mongoDB数据库，效率不高！！！

吐槽微服务：吐槽点赞（第二种方案）

目标

关键步骤和核心代码

代码：

//mongoTemplate: 封装了MongoDB对集合所有操作的方法
@Autowired
private MongoTemplate mongoTemplate;

 /**
  * 吐槽点赞（第二种方案）--效率更高
  */
 public void thumbup(String id){

     //创建Query对象封装： {"_id":"1086835055109640192"}
     Query query = new Query();
     query.addCriteria(Criteria.where("_id").is(id));

     //创建更新对象：{$inc:{"thumbup":NumberInt(1)}}
     Update update = new Update();
     update.inc("thumbup",1);

     //底层：db.spit.update(  {"_id":"1086835055109640192"},{$inc:{"thumbup":NumberInt(1)}}  )
     mongoTemplate.updateFirst(query,update,"spit");

 }

小结

总结mongoTemplate实现列增长步骤

mongoTemplate.updateFirst(query,update,“spit”);

吐槽微服务：控制用户不能重复点赞

目标

使用Redis记录用户吐槽点赞记录，实现用户不能重复点赞功能

关键步骤和核心代码

1）在Docker启动redis

2）在吐槽微服务引入spring-data-redis坐标

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

3）配置application.yml连接redis

redis:
  host: 192.168.139.128

4）在需要的位置注入RedisTemplate使用

public Result thumbup(@PathVariable String id){
    //模拟当前登录用户ID
    String userid = "1001";

    //1.从redis查询该用户是否已经点赞
    String flag = (String)redisTemplate.opsForValue().get("thumbup_"+userid+"_"+id);

    //1.1 如果已经点赞，提示用户不能重复点赞
    if(flag!=null && flag.equals("1")){
        return new Result(false,StatusCode.REPEATE_ERROR,"不能重复点赞");
    }

    //1.2 如果没有点赞过，则进行点赞
    spitService.thumbup(id);

    //把用户的点赞保存redis去
    redisTemplate.opsForValue().set("thumbup_"+userid+"_"+id,"1",1, TimeUnit.DAYS);

    return new Result(true,StatusCode.OK,"点赞成功");
}

小结

总结控制用户不能重复点赞的过程

吐槽微服务：完善增加吐槽（增加回复数）

目标

完善增加吐槽方法，补充吐槽评论后，吐槽的回复数+1的效果

关键步骤和核心代码

查询的方法也变了：查询出来的列表的parentid是为空

service:

	//查询所有
	public List<Spit> findAll(){
		//return spitDao.findAll();
		return spitDao.findByParentidIsNull();
	}

dao:

	/**
	 * 查询的是非评论吐槽数据
	 * @return
	 */
	public List<Spit> findByParentidIsNull();

/**
 * 添加
 */
public void add(Spit spit){
    //设置id
    spit.setId(idWorker.nextId()+"");
    spitDao.save(spit);

    //如果该信息为评论，则添加评论对应的吐槽的回复数+1
    if( spit.getParentid()!=null && !spit.getParentid().equals("")){
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(spit.getParentid()));

        Update update = new Update();
        update.inc("comment",1);

        mongoTemplate.updateFirst(query,update,"spit");
    }

}

小结

总结添加回复数的过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lYNkiCxH-1581138771883)(十次方笔记.assets/1580089711216.png)]

13.tensquare-user 用户微服务用户注册：分析需求及代码生成

目标：

1、理解短信微服务的需求
2、使用代码生成工具生成代码

分析步骤：

1）用户先填入手机号码

2）点击获取验证码按钮

3）后台接收用户手机号码，生成一个随机数，存储redis中，并且往消息队列中生产一条数据

4）短信微服务监听消息队列短信消息

5）接收到就使用阿里短信给用户手机号码发送验证码

6）用户接收到验证码后填写其他的用户信息，提交注册

7）后台从缓存中查询验证码与用户注册提交的验证码相对比

8）如果一致，则可以注册；否则不能注册

代码生成：

小结：

脑海中要知道消息队列【RabbitMQ】怎么跑的

用户注册：发送手机验证码

目标：

搭建用户微服务

开发思路：

1、获取用户输入的手机号码
2、在系统生成随机数字验证码
3、把验证码存入redis
4、把手机号码和验证码一起发送到RabbitMQ

开发步骤：

1）快速生成用户微服务代码，导入起步依赖

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

2）配置application.yml

  redis:
    host: 192.168.139.128
  rabbitmq:
    host: 192.168.139.128

3）编写Controller

	@RequestMapping(value="/sendsms/{mobile}",method= RequestMethod.POST)
	public Result sendsms(@PathVariable String mobile ){
		userService.sendsms(mobile);
		return new Result(true,StatusCode.OK,"短信发送成功，请注意查收");
	}

4）编写Service

生成随机验证码

	  
	  <dependency>
		  <groupId>commons-langgroupId>
		  <artifactId>commons-langartifactId>
		  <version>2.6version>
	  dependency>

	//redis模板
	@Autowired
	private RedisTemplate redisTemplate;
	
	//消息队列的模板
	@Autowired
	private RabbitMessagingTemplate rabbitMessagingTemplate;
	

	/**
	 * 发送短信验证码
	 * @param mobile
	 */
	public void sendsms(String mobile) {
		//判空
		if(mobile==null||"".equals(mobile)){
			throw new RuntimeException("手机号码不能为空");
		}
		//生成随机的字符串
		String numcode = RandomStringUtils.randomNumeric(4);
		
		//存入redis中，并且设置5分钟的过期时间
		String key = "sendsms_"+mobile;
		redisTemplate.opsForValue().set(key, numcode, 5, TimeUnit.MINUTES);
		
		//生产消息：把手机号+验证码一起发送到队列中即可
		Map<String, String> map = new HashMap<>();
		map.put("mobile",mobile);
		map.put("code", numcode);
		rabbitMessagingTemplate.convertAndSend("tensquare",map);
		
	}

小结：

熟读开发思路

用户注册：搭建短信微服务及监听消息

目标：

掌握搭建短信微服务及监听消息

核心步骤：

1）建立短信微服务

2）导入RabbitMQ坐标

3）编写application.yml

4）编写启动类

5）编写短信监听类

package com.tensquare.sms.consumer;

import java.util.Map;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues="tensquare")
public class SmsConsumer {
	
	@RabbitHandler
	public void sms(Map<String ,String> map) {
		//消费者发送短信
		String mobile = map.get("mobile");//手机号
		String code = map.get("code");//验证码
		System.out.println("发送短信："+mobile+"====>验证码："+code);
	}

}

小结：

开发流程记忆一下，细节不用背

用户注册：阿里大于（短信）发送手机验证码

目标：

掌握使用阿里短信发送手机验证码

核心步骤：

阿里短信介绍：

1）注册和登录阿里云网站
2）找到 控制台->产品-> 短信服务->国内消息
3）添加短信签名和短信模板【需要企业资质或者认证的网站】
4）生成阿里云的accesskey
5）充值

开发步骤：

1）在短信微服务中导入阿里云的短信坐标

<dependency>
    <groupId>com.aliyungroupId>
    <artifactId>aliyun-java-sdk-dysmsapiartifactId>
    <version>1.0.0-SNAPSHOTversion>
dependency>
<dependency>
    <groupId>com.aliyungroupId>
    <artifactId>aliyun-java-sdk-coreartifactId>
    <version>3.2.5version>
dependency>

2）把Demo代码制作成SmsUtil工具类

package com.tensquare.sms.utils;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.dysmsapi.model.v20170525.QuerySendDetailsRequest;
import com.aliyuncs.dysmsapi.model.v20170525.QuerySendDetailsResponse;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.profile.IClientProfile;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;
/**
 * 短信工具类
 * @author Johnny
 *
 */
@Component
public class SmsUtil {

    //产品名称:云通信短信API产品,开发者无需替换
    static final String product = "Dysmsapi";
    //产品域名,开发者无需替换
    static final String domain = "dysmsapi.aliyuncs.com";

    @Autowired
    private Environment env;

    // TODO 此处需要替换成开发者自己的AK(在阿里云访问控制台寻找)

    /**
     * 发送短信
     * @param mobile 手机号
     * @param template_code 模板号
     * @param sign_name 签名
     * @param param 参数
     * @return
     * @throws ClientException
     */
    public SendSmsResponse sendSms(String mobile,String template_code,String sign_name,String param) throws ClientException {
        String accessKeyId =env.getProperty("aliyun.sms.accessKeyId");
        String accessKeySecret = env.getProperty("aliyun.sms.accessKeySecret");
        //可自助调整超时时间
        System.setProperty("sun.net.client.defaultConnectTimeout", "10000");
        System.setProperty("sun.net.client.defaultReadTimeout", "10000");
        //初始化acsClient,暂不支持region化
        IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);
        DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
        IAcsClient acsClient = new DefaultAcsClient(profile);
        //组装请求对象-具体描述见控制台-文档部分内容
        SendSmsRequest request = new SendSmsRequest();
        //必填:待发送手机号
        request.setPhoneNumbers(mobile);
        //必填:短信签名-可在短信控制台中找到
        request.setSignName(sign_name);
        //必填:短信模板-可在短信控制台中找到
        request.setTemplateCode(template_code);
        //可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
        request.setTemplateParam(param);
        //选填-上行短信扩展码(无特殊需求用户请忽略此字段)
        //request.setSmsUpExtendCode("90997");
        //可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
        request.setOutId("yourOutId");
        //hint 此处可能会抛出异常，注意catch
        SendSmsResponse sendSmsResponse = acsClient.getAcsResponse(request);
        return sendSmsResponse;
    }

    public  QuerySendDetailsResponse querySendDetails(String mobile,String bizId) throws ClientException {
        String accessKeyId =env.getProperty("accessKeyId");
        String accessKeySecret = env.getProperty("accessKeySecret");
        //可自助调整超时时间
        System.setProperty("sun.net.client.defaultConnectTimeout", "10000");
        System.setProperty("sun.net.client.defaultReadTimeout", "10000");
        //初始化acsClient,暂不支持region化
        IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);
        DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
        IAcsClient acsClient = new DefaultAcsClient(profile);
        //组装请求对象
        QuerySendDetailsRequest request = new QuerySendDetailsRequest();
        //必填-号码
        request.setPhoneNumber(mobile);
        //可选-流水号
        request.setBizId(bizId);
        //必填-发送日期 支持30天内记录查询，格式yyyyMMdd
        SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");
        request.setSendDate(ft.format(new Date()));
        //必填-页大小
        request.setPageSize(10L);
        //必填-当前页码从1开始计数
        request.setCurrentPage(1L);
        //hint 此处可能会抛出异常，注意catch
        QuerySendDetailsResponse querySendDetailsResponse = acsClient.getAcsResponse(request);
        return querySendDetailsResponse;
    }
}

3）使用SmsUtil发送短信

@Component
@RabbitListener(queues = "itcast")
public class SmsListener {

    @Value("${aliyun.sms.template_code}")
    private String template_code;//模板号

    @Value("${aliyun.sms.sign_name}")
    private String sign_name;//短信签名

    @Autowired
    private SmsUtil smsUtil;

    @RabbitHandler
    public void smsMessage(Map<String,String> msg){
        System.out.println("用户手机号码："+msg.get("mobile"));
        System.out.println("用户验证码："+msg.get("code"));
        try {
            smsUtil.sendSms(msg.get("mobile"),template_code,sign_name,"{\"code\":\""+msg.get("code")+"\"}");
        } catch (ClientException e) {
            e.printStackTrace();
        }
    }
}

4）配置application.yml

server:
  port: 9009
spring:
  rabbitmq:
    host: 192.168.207.111
#短信发送
aliyun:
  sms:
    accessKeyId: 用自己的
    accessKeySecret: 用自己的
    template_code: SMS_160305839
    sign_name: 陈飞的博客

小结：

1、能向面试官介绍阿里短信
2、掌握短信发送的业务流程

用户注册：完成注册功能

目标：

完成用户的注册功能

思路：

1、获取验证码和用户注册信息
2、从redis中取出系统生成的验证码
3、对比用户发送过来的和redis中的验证码是否一致
4、如果一致，返回true，并保存用户信息；如果不一致，返回false，并提示用户验证码错误

开发步骤：

1）Controller

	/**
	 * 用户注册
	 * @param code
	 * @return
	 */
	@PostMapping("/register/{code}")
	public Result register(@PathVariable String code,@RequestBody User user) {
		//调用service方法即可
		userService.register(code,user);
		//直接返回成功
		return new Result(true,StatusCode.OK,"恭喜：用户注册成功");
	}

2）Service

	/**
	 * 用户注册
	 * @param code   手机验证码
	 * @param user   用户实体
	 */
	public void register(String code, User user) {
		//从缓存中获取标记
		//if(user.getMobile()==null||"".equals(user.getMobile())) {
		if(StringUtils.isBlank(user.getMobile())) {
			throw new RuntimeException("手机号码不能为空");
		}
		if(StringUtils.isBlank(code)) {
			throw new RuntimeException("手机验证码不能为空");
		}
		//获取标记
		String key = "sendsms_"+user.getMobile();
		String numcode = (String) redisTemplate.opsForValue().get(key);
		
		//判断是否一致
		if(!code.equals(numcode)) {
			throw new RuntimeException("手机验证码已经过期，请重新获取短信验证码！");
		}
		
		//可以给用户注册
		user.setId( idWorker.nextId()+"" );
		user.setRegdate(new Date());
		user.setOnline(0L);
		user.setFanscount(0);
		user.setFollowcount(0);
		userDao.save(user);
		
	}

小结：

能给面试官讲清楚我们的MQ用在十次方系统的那一块

14.加密与权限 BCrypt 与 JWT

核心步骤：

了解BCrypt加密算法

常见的密码算法：
	MD5加密： 破解风险比较大
	MD5+加盐：破解风险相对小
	BCrypt加密：类似于MD5加盐
		hash加密 + 加随机盐(salt)   = 密码（包含盐的值）

在用户微服务导入BCrypt加密工具类

前置：BCryptPasswordEncoder来自于SpringSecurity框架。

1）在用户微服务导入spring-security坐标

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

2）编写一个spring-security配置类，放行所有请求

/**
 * 安全配置类
 */
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter
{
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/**").permitAll()
                .anyRequest().authenticated()
                .and().csrf().disable();
    }
}

3）在启动类实例化BCryptPasswordEncoder

@Bean
public BCryptPasswordEncoder bCryptPasswordEncoder(){
   return new BCryptPasswordEncoder();
}

小结：

请问BCrypt加密的盐存储在哪里？
存储最后加密后的密码

$2a $10$ MuU0WSDHSIOM9wu0f4MVL.nrs47fXv9RgkSSVs/fi1x2XrHkv9b8m

管理员密码加密与登录

目标：

1）掌握BCrypt工具类对管理员密码加密
2）掌握BCrypt工具类判断密码是否一致

开发思路：

1）管理员登录提交登录名和密码
2）在Controller接收登录名和密码调用service，返回Admin
     如果Admin为空，代表登录失败
     如果Admin不为空，代表登录成功

3）在Service我们需要调用BCryptPasswordEncoder判断密码是否正确
	 如果密码一致，返回Admin对象
	 如果密码不一致，返回null

开发步骤：

1、AdminService类

@Autowired
private BCryptPasswordEncoder encoder;

/**
 * 增加
 * @param admin
 */
public void add(Admin admin) {
   admin.setId( idWorker.nextId()+"" );
   //对密码进行BCrypt加密
   admin.setPassword(encoder.encode(admin.getPassword()));
   adminDao.save(admin);
}

/**
 * 登录
 */
public Admin login(Admin admin){
   //1.判断账户是否存在
   Admin loginAdmin = adminDao.findByLoginname(admin.getLoginname());

   //2.如果账户存在，判断密码是否一致
   /**
    * matches()方法底层：
    * 1）使用数据库存储密码 提取出 盐（salt）
    * 2）使用用户登录时输入的密码 进行 哈希加密，再使用 上一步提取的盐进行 加密，得到新密码
    * 3）把数据库的密码 和 第二步加密的密码进行匹配，如果一致的，返回true，否则，返回false
    */
   if(loginAdmin!=null &&  encoder.matches(admin.getPassword(),loginAdmin.getPassword())  ){
      return loginAdmin;
   }else{
      return null;
   }
}

2、AdminController【添加管理员方法不用变】

/**
 * 登录
 */
@RequestMapping(value = "/login",method = RequestMethod.POST)
public Result login(@RequestBody Admin admin){
   Admin loginAdmin = adminService.login(admin);
   
   if(loginAdmin==null){
      //登录失败
      return new Result(false,StatusCode.USER_PASS_ERROR,"登录失败：用户名户或密码错误");
   }else{
      //登录成功
      
      //如何认证，后面再看？
      
      return new Result(true,StatusCode.OK,"登录成功");
   }
}

3、AdminDao

public interface AdminDao extends JpaRepository<Admin,String>,JpaSpecificationExecutor<Admin>{

    public Admin findByLoginname(String loginname);
}

小结：

请问哪个方法对密码加密？哪个方法判断密码是否一致？

加密：encode()
判断密码一致：matches()

用户密码加密与登录

目标：

1）掌握BCrypt工具类对用户密码加密
2）掌握BCrypt工具类判断用户是否一致

核心步骤：

1、UserService

@Autowired
private BCryptPasswordEncoder encoder;

/**
 * 增加
 * @param user
 */
public void add(User user) {
   user.setId( idWorker.nextId()+"" );
   user.setPassword(encoder.encode(user.getPassword()));
   userDao.save(user);
}

/**
 * 登录
 */
public User login(User user){
   //1.判断用户是否存在
   User loginUser = userDao.findByMobile(user.getMobile());
   
   //2.如果用户存在，判断密码是否一致
   if(loginUser!=null && encoder.matches(user.getPassword(),loginUser.getPassword()) ){
      return loginUser;
   }else{
      return null;
   }
}

2、UserController【只有登录方法】

/**
 * 登录
 */
@RequestMapping(value = "/login",method = RequestMethod.POST)
public Result login(@RequestBody User user){
   User loginUser = userService.login(user);
   
   if(loginUser==null){
      return new Result(false,StatusCode.USER_PASS_ERROR,"登录失败；手机号码或密码错误");
   }else{
      return new Result(true,StatusCode.OK,"登录成功");
   }
}

3、UserDao

public interface UserDao extends JpaRepository<User,String>,JpaSpecificationExecutor<User>{

    public User findByMobile(String mobile);
}

小结：

掌握加密和判断密码的逻辑

15.tensquare-spider 爬虫微服务

爬虫的实现技术

java中的爬虫技术：

1）底层技术
HttpClient+Jsoup



2）爬虫框架
Webmagic

官网：http://webmagic.io/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g03yIXeD-1581138771885)(十次方笔记.assets/1563264343715.png)]

webmagic的执行流程

WebMagic的结构分为Downloader、PageProcessor、Scheduler、Pipeline四大组件，并由Spider将它们彼此组织起来。这四大组件对应爬虫生命周期中的下载、处理、管理和持久化等功能。

WebMagic的结构分为Downloader、PageProcessor、Scheduler、Pipeline四大组件，并由Spider将它们彼此组织起来

关键画图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HetEFXrk-1581138771886)(十次方笔记.assets/1563264405119.png)]

PageProcessor：爬取整个网页内容

核心代码：

package com.itheima.webmagic;

import us.codecraft.webmagic.Page;
import us.codecraft.webmagic.Site;
import us.codecraft.webmagic.Spider;
import us.codecraft.webmagic.processor.PageProcessor;

public class MyPageProcessor implements PageProcessor {
    /**
     * 解析网页内容
     */
    @Override
    public void process(Page page) {
        //输出整个网页内容
        System.out.println(page.getHtml().toString());
    }

    /**
     * 设置爬取参数
     */
    @Override
    public Site getSite() {
        return Site.me()
                .setSleepTime(100)// 设置爬取间隔时间
                .setTimeOut(3000)// 设置爬取超时时间
                .setRetryTimes(3);// 设置重试次数
    }

    public static void main(String[] args) {
        /**
         * 入口
         */
        Spider.create(new MyPageProcessor()).addUrl("https://blog.csdn.net/").start();
    }
}

PageProcessor：xpath爬取指定内容

xpath语法解析：

<html>
   <head>
      <title>文章标题1title>
  head>
   <title>文章标题2title>
  <body>
     <div id="d1">div1div>
     <div class="c2">div2div>
     <div>div3div>
     <div class="c2">div4div>
  body>
html>


需求：
1）获取title标签：   
          /html/head/title
         //title

2)获取div标签
        /html/body/div
       //div

3)获取第二div
      //div[2]

4)获取最后一个div
     //div[last()]

5) 获取有属性的div
     //div[@]

6)获取有id属性的div
     //div[@id]

7)获取id属性值为d1的div
     //div[@id='d1']	

8)获取head下所有标签
      //head/*

去讲义的这个地方看语法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ygyaFJwr-1581138771886)(十次方笔记.assets/1563264465692.png)]

//*[@id=“mainScreen”]/div/div/div/div[1]/div[2]/a[6]

通过浏览器获取xpath信息：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WnkTskCh-1581138771886)(十次方笔记.assets/.png)]

核心代码：

package com.itheima.webmagic;

import us.codecraft.webmagic.Page;
import us.codecraft.webmagic.Site;
import us.codecraft.webmagic.Spider;
import us.codecraft.webmagic.processor.PageProcessor;

public class MyPageProcessor implements PageProcessor {
    /**
     * 解析网页内容
     */
    @Override
    public void process(Page page) {
        //爬取指定网页内容（xpath表达式）
        String content = page.getHtml().xpath("//*[@id=\"nav\"]/div/div/ul/li[13]/a").toString();
        String content2 = page.getHtml().xpath("//*[@id=\"nav\"]/div/div/ul/li[13]/a/text()").toString();
        System.out.println(content);
        System.out.println(content2);

    }

    /**
     * 设置爬取参数
     */
    @Override
    public Site getSite() {
        return Site.me()
                .setSleepTime(100)// 设置爬取间隔时间
                .setTimeOut(3000)// 设置爬取超时时间
                .setRetryTimes(3);// 设置重试次数

    }

    public static void main(String[] args) {
        /**
         * 入口
         */
        Spider
                .create(new MyPageProcessor())
                .addUrl("https://blog.csdn.net/")
                .start();
    }
}

PageProcessor：爬取所有目标url与正则表达式过滤

核心代码：

package com.itheima.webmagic;

import us.codecraft.webmagic.Page;
import us.codecraft.webmagic.Site;
import us.codecraft.webmagic.Spider;
import us.codecraft.webmagic.processor.PageProcessor;

public class MyPageProcessor implements PageProcessor {
    /**
     * 解析网页内容
     */
    @Override
    public void process(Page page) {
        //添加当前页面下的其他所有超链接
        //page.addTargetRequests(page.getHtml().links().all());


        //添加指定抓取页面
        page.addTargetRequests(page.getHtml().regex("https://blog.csdn.net/[a-zA-Z0-9_]+/article/details/[0-9]{8}").all());

    }

    /**
     * 设置爬取参数
     */
    @Override
    public Site getSite() {
        return Site.me()
                .setSleepTime(100)// 设置爬取间隔时间
                .setTimeOut(3000)// 设置爬取超时时间
                .setRetryTimes(3);// 设置重试次数

    }

    public static void main(String[] args) {
        /**
         * 入口
         */
        Spider
                .create(new MyPageProcessor())
                .addUrl("https://blog.csdn.net/")
                .start();
    }
}

开源中国

package com.itheima.processer;

import us.codecraft.webmagic.Page;
import us.codecraft.webmagic.Site;
import us.codecraft.webmagic.Spider;
import us.codecraft.webmagic.processor.PageProcessor;

/**
 * 我们自己的处理器
 */
public class MyPageProcesser implements PageProcessor{
    /**
     * 处理，解析页面
     */
    @Override
    public void process(Page page) {
        //1、输出页面的内容
        //System.out.println(page.getHtml().toString());

        //2、通过xpath获取指定的内容
        //System.out.println(page.getHtml().xpath("//*[@id=\"mainScreen\"]/div/div[1]/div/div[1]/div[1]/a[2]").toString());
        //System.out.println(page.getHtml().xpath("//*[@id=\"mainScreen\"]/div/div[1]/div/div[1]/div[1]/a[2]/text()").toString());

        //3、爬取指定的url
        //3.1 所有url
        //System.out.println(page.getHtml().links().all().toString());
        //page.addTargetRequests(page.getHtml().links().all()); //进入所有连接的页面

        //3.2 使用正则表达式解析具体url
        //System.out.println(page.getHtml().regex("https://my.oschina.net/u/[0-9]{7}/blog/[0-9]{7}").all().toString());
        page.addTargetRequests(page.getHtml().regex("https://my.oschina.net/u/[0-9]+/blog/[0-9]+").all());


    }

    /**
     * 站点处理：超时的时间，重试次数等
     */
    @Override
    public Site getSite() {
        return Site.me()
                .setSleepTime(300)//爬取完一次，休眠时间
                .setTimeOut(3000)//设置超时时间
                .setRetryTimes(3)//设置重试次数
                ;
    }

    /**
     * 运行
     */
    public static void main(String[] args) {

        Spider
                .create(new MyPageProcesser())// 创建
                .addUrl("https://www.oschina.net/blog") //加入页面链接
                .start(); //开始爬取
        ;

    }
}

Pipeline：控制台、文件、定制输出

核心代码：

1）MyPageProcessor 类

package com.itheima.processer;

import com.itheima.pipeline.MyDBPipeline;
import us.codecraft.webmagic.Page;
import us.codecraft.webmagic.Site;
import us.codecraft.webmagic.Spider;
import us.codecraft.webmagic.pipeline.ConsolePipeline;
import us.codecraft.webmagic.pipeline.FilePipeline;
import us.codecraft.webmagic.pipeline.JsonFilePipeline;
import us.codecraft.webmagic.processor.PageProcessor;

/**
 * 我们自己的处理器
 */
public class MyPageProcesser implements PageProcessor{
    /**
     * 处理，解析页面
     */
    @Override
    public void process(Page page) {
        //1、输出页面的内容
        //System.out.println(page.getHtml().toString());

        //2、通过xpath获取指定的内容
        //System.out.println(page.getHtml().xpath("//*[@id=\"mainScreen\"]/div/div[1]/div/div[1]/div[1]/a[2]").toString());
        //System.out.println(page.getHtml().xpath("//*[@id=\"mainScreen\"]/div/div[1]/div/div[1]/div[1]/a[2]/text()").toString());

        //3、爬取指定的url
        //3.1 所有url
        //System.out.println(page.getHtml().links().all().toString());
        //page.addTargetRequests(page.getHtml().links().all()); //进入所有连接的页面

        //3.2 使用正则表达式解析具体url
        //System.out.println(page.getHtml().regex("https://my.oschina.net/u/[0-9]{7}/blog/[0-9]{7}").all().toString());
        page.addTargetRequests(page.getHtml().regex("https://my.oschina.net/u/[0-9]+/blog/[0-9]+").all());


        //4、往pipeline传递值
        String title = page.getHtml().xpath("//*[@id=\"mainScreen\"]/div/div[1]/div/div[2]/div[1]/div[2]/h2/text()").toString();
        if(title!=null && title.length()>0){
            page.putField("title",title);
        }else{
            //如果为空跳过
            page.setSkip(true);//跳过当前页面
        }


    }

    /**
     * 站点处理：超时的时间，重试次数等
     */
    @Override
    public Site getSite() {
        return Site.me()
                .setSleepTime(300)//爬取完一次，休眠时间
                .setTimeOut(3000)//设置超时时间
                .setRetryTimes(3)//设置重试次数
                ;
    }

    /**
     * 运行
     */
    public static void main(String[] args) {

        Spider
                .create(new MyPageProcesser())// 创建
                .addUrl("https://www.oschina.net/blog") //加入页面链接
                .addPipeline(new ConsolePipeline()) //输出内容到控制台的
                .addPipeline(new FilePipeline("D:/code/1024/o_ai_day01/file/"))//往文件中输出
                .addPipeline(new JsonFilePipeline("D:/code/1024/o_ai_day01/jsonfile/"))//往文件中输出
                .addPipeline(new MyDBPipeline()) //添加自定义的pipeline
                .start(); //开始爬取
        ;

    }
}

2）定制输出类：MyPipeline

package com.itheima.pipeline;

import us.codecraft.webmagic.ResultItems;
import us.codecraft.webmagic.Task;
import us.codecraft.webmagic.pipeline.Pipeline;

/**
 * 自定义pipeline
 */
public class MyDBPipeline implements Pipeline{
    /**
     * 自定义持久化的策略
     */
    @Override
    public void process(ResultItems resultItems, Task task) {
        //输出内容
        System.out.println("MyDBPipeline 插入数据库。。。。。"+ resultItems.get("title").toString());

        //插入数据库
        //System.out.println("插入数据库。。。。。");

    }
}

Scheduler：URL存储

核心代码：

package com.itheima.webmagic;

import us.codecraft.webmagic.Page;
import us.codecraft.webmagic.Site;
import us.codecraft.webmagic.Spider;
import us.codecraft.webmagic.pipeline.ConsolePipeline;
import us.codecraft.webmagic.pipeline.FilePipeline;
import us.codecraft.webmagic.pipeline.JsonFilePipeline;
import us.codecraft.webmagic.processor.PageProcessor;
import us.codecraft.webmagic.scheduler.FileCacheQueueScheduler;
import us.codecraft.webmagic.scheduler.QueueScheduler;
import us.codecraft.webmagic.scheduler.RedisPriorityScheduler;

public class MyPageProcessor implements PageProcessor {
    /**
     * 解析网页内容
     */
    @Override
    public void process(Page page) {

        //添加指定抓取页面
        page.addTargetRequests(page.getHtml().regex("https://blog.csdn.net/[a-zA-Z0-9_]+/article/details/[0-9]{8}").all());

        //往ResultItem对象添加需要添加的内容
        page.putField("title",page.getHtml().xpath("//*[@id=\"mainBox\"]/main/div[1]/div/div/div[1]/h1/text()").toString());

    }

    /**
     * 设置爬取参数
     */
    @Override
    public Site getSite() {
        return Site.me()
                .setSleepTime(100)// 设置爬取间隔时间
                .setTimeOut(3000)// 设置爬取超时时间
                .setRetryTimes(3);// 设置重试次数

    }

    public static void main(String[] args) {
        /**
         * 入口
         */
        Spider
                .create(new MyPageProcessor())
                .addUrl("https://blog.csdn.net/")
                .addPipeline(new ConsolePipeline())
                .addPipeline(new FilePipeline("D:\\code\\file\\"))
                .addPipeline(new JsonFilePipeline("D:\\code\\jsonfile\\"))
                .addPipeline(new MyPipeline())
                //.setScheduler(new QueueScheduler())
                //.setScheduler(new FileCacheQueueScheduler("D:\\code\\url\\"))
                .setScheduler(new RedisPriorityScheduler("192.168.207.111"))
                .start();
    }
}

1、放入到内存队列：缺点，重启就没有了

2、存入文件中，它不适合分布式系统

3、存入redis中，它适用于分布式系统

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

回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
SQLite的入门级项目学习记录（二）深蓝海拓 SQLite学习笔记 sqlite 学习数据库
再补充一些基础知识：并行操作的问题1、可以多游标同时运行SQLite，对于同一个连接sqlite3.connect(db_file)，可以同时创建多个游标，每个游标都是独立的，可以执行各自的SQL命令序列。importsqlite3#创建数据库连接conn=sqlite3.connect('example.db')#创建第一个游标cursor1=conn.cursor()cursor1.execu
RISC-V架构生态及相关学习记录我朝山海而去 risc-v 学习
从网络整理，仅供自己学习_____________________________________________________________________________1.RISC-V架构的两个特性RISC-V，第五代精简指令处理器。RISC-V指令集，可以在理解上类比于主流商用Inter的x86，ARM的指令集，用于CPU读取、翻译从而指挥计算机进行相应操作。它在RISC（基于精简指令
英语心得1 小坤的梦呓
姑且这段学习记录的名字就这么叫吧。现在看了很多学习方面的经验分享，自己也在实践当中。正如贾兄在经验分享中看到的那样，学习英语而不是学习知识。英语是语言，语言是用来说的，既然要说语言，那必然要从听开始。很多原理和道理也不细说了，这个还需要学习很久。我现在要做的就是根据这些经验和自己的感悟去学习，然后加以改进方法，提高学习效率。现在也有给自己定了一个短期的小目标，争取年底或明年初可以考过雅思。至少达到
man命令学习记录天南地北飞 linux基础学习学习 linux 运维
使用man来查看命令的用法manls想了解Linux命令的用法假设你想查ls命令的更多信息，输入manls，就会打开manpage（man是manual的缩写，因此manpage就是“手册页面”），显示关于ls命令各个方面的信息。通常，manpage是由编写程序的开发人员编写的。使用这个命令并不难，只需要输入man，后面再跟上你想要了解的命令。$manlsLS(1)UserCommandsLS(1
C语言简单复习(在力扣上刷题）【学习记录】清蒸君 51单片机 c语言 leetcode
一、魔术索引在数组A[0...n-1]中，有所谓的魔术索引，满足条件A[i]=i。给定一个有序整数数组，编写一种方法找出魔术索引，若有的话，在数组A中找出一个魔术索引，如果没有，则返回-1。若有多个魔术索引，返回索引值最小的一个。示例1:输入：nums=[0,2,3,4,5]输出：0说明:0下标的元素为0来源：力扣（LeetCode）链接：https://leetcode-cn.com/probl
推荐算法学习记录2.2——kaggle数据集的动漫电影数据集推荐算法实践——基于内容的推荐算法、协同过滤推荐萱仔学习自我记录推荐算法学习 python matplotlib 开发语言
1、基于内容的推荐：这种方法根据项的相关信息（如描述信息、标签等）和用户对项的操作行为（如评论、收藏、点赞等）来构建推荐算法模型。它可以直接利用物品的内容特征进行推荐，适用于内容较为丰富的场景。‌#1.基于内容的推荐算法fromsklearn.feature_extraction.textimportTfidfVectorizerfromsklearn.metrics.pairwiseimport
LeetCode hot 100 学习记录 day 2 a77895 leetcode 学习算法
文章目录Integer方法除自身以外数组的乘积缺失的第一个正数参考链接Integer方法由轮转数组到Interger方法、System方法轮转数组：涉及到的方法：System.arraycopy(newArr,0,nums,0,n)nums.assign(newArr.begin(),newArr.end());方法介绍：publicstaticnativevoidarraycopy(Object
学习记录——day43 C++ 异常处理子座学习
一、异常处理的格式1、在可能产生异常的地方使用关键字：throw抛出异常2、try{可能会抛出异常的语句}catch(接收异常的形参){处理异常}任何函数在定义时，可以指定能抛出的异常格式如下返回值类型函数名(形参列表)throw(异常类型1，异常类型2，。。。。)定义时throw没有不影响函数体内throw的使用，系统会自动匹配，如果有，内外类型要一致，不能缺少对于一定不会抛出异常的函数，可用n
9.6学习记录+三场笔试冰榫学习
一、去哪儿笔试+挚文集团1.在调度算法中平均等待时间最短的是什么?短作业优先2.给定一个字符串s，最有效的找到其中第一个不重复的字符的方法是?一、使用哈希表创建一个哈希表，用于存储字符及其出现的次数。可以使用编程语言中提供的字典（如Python中的dict）或类似的数据结构。遍历字符串s：对于每个字符，检查它是否在哈希表中。如果不在哈希表中，将其加入哈希表，并将其出现次数初始化为1。如果已经在哈希
Groovy入门（有java基础） black_dawn groovy java 开发语言
一、基本概念Groovy是一种基于Java虚拟机（JVM）的动态开发语言，旨在扩展Java语法，提供更简洁、灵活和易于使用的编码方式。本文是在会一定java语言开发的基础上进行的对比入门学习记录。1.特点：动态性：Groovy支持动态类型和动态元编程，使得代码更加灵活和易于编写。简洁性：Groovy的语法相对于Java来说更加简洁，可以用更少的代码实现相同的功能。闭包：Groovy提供了强大的闭包
搭载python环境 guluguluduang 学习记录区 00000001
超级小白学习记录搭载python环境一：找官网下载python二：python是否可以在电脑上找到，用cmd打一下python看看是否有弹出三：有弹出直接用，无弹出信息则用环境变量改一下四：环境变量在高级系统设置中，双击系统设置中的path新建一个自己的python文件五：下载geany用于编程，新建一个文件夹叫xx.py。后缀.py可让geany识别出这是个python的文件，以便于让geany
学习记录——语义分割和实例分割的标签结构落叶击球学习笔记学习人工智能
语义分割：一张样本，生成一张掩码图像标签。灰度图像，背景亮度为0，每个目标根据分类赋予不同亮度——1，2，3......实现像素级的类别区分，但无法区分个体。实例分割：原理：一张样本，生成一个多通道的Mat矩阵，也就是多张掩码图像叠在一起。每张掩码图负责存储一个类别的目标，亮度只有0和1，通过通道号区分每个类别。同时，每张掩码图内，每个目标拥有ID号（通过增加一个维度实现），负责区分一个类别中的每
开开心心最重要进步记录2020
1.难得2月9号，10号这两天没什么工作内容，不过我也充分利用了这两天，闲里时间，紧张的学习记录一些文章套路，为以后写文章打下一定的基础，但愿还是有用的吧。毕竟勤能补拙是真理，再加上潜移默化的学习熏陶，估计会有用。2.今天站闲里忙着买了家电，京东3000多点买了空调，拼多多888买了冰箱，三开门的，应该还可以。但愿安装费时候没有什么事情，祝一切顺利。3这两天不知道为什么，神经总是很紧张，也不知道怎
冶金加热炉学习记录11加热制度改善昨天的自己
11、加热炉的热制度正确选择钢坯加热工艺，不仅要考虑钢坯的加热温度，还应考虑断面上的温度差，即温度的均匀性。加热炉热制度的确定是进行物料加热计算的前提，也是炉子投产后热工操作制度的依据。钢种不同，料坯的形状、尺寸不同，加热炉的热制度亦应有所区别。对压力加工前的钢坯加热炉而言，钢坯的加热制度可分为：一段加热制度、二段加热制度、三段加热制度。一段式加热制度（也称一期加热制度）是把钢坯放在炉温基本上不变
Flutter学习记录-基础控件薰舞空
statelesswidget没有内部状态.Icon、IconButton,和Text都是无状态widget,他们都是StatelessWidget的子类。statefulwidget是动态的.用户可以和其交互(例如输入一个表单、或者移动一个slider滑块),或者可以随时间改变(也许是数据改变导致的UI更新).Checkbox,Radio,Slider,InkWell,Form,andTextF
（深度学习记录）：第T3周：天气识别 liuyiqi1 深度学习人工智能
>-**本文为[365天深度学习训练营](https://mp.weixin.qq.com/s/rbOOmire8OocQ90QM78DRA)中的学习记录博客**>-**原作者：[K同学啊|接辅导、项目定制](https://mtyjkh.blog.csdn.net/)**我的环境-语言环境：Python3.11-编译器：PyCharm-tensorflow版本2.14.0代码部分importos
第R3周：天气预测 Jessica2017lj python
本文为[365天深度学习训练营]中的学习记录博客参考文章：第R3周：LSTM-火灾温度预测（训练营内部可读）作者：[K同学啊]任务说明：该数据集提供了来自澳大利亚许多地点的大约10年的每日天气观测数据。你需要做的是根据这些数据对RainTomorrow进行一个预测，这次任务任务与以往的不同，我增加了探索式数据分析（EDA），希望这部分内容可以帮助到大家。我的环境：●语言环境：Python3.8●编
T4周：猴痘病识别 KLaycurryifans 深度学习
本文为365天深度学习训练营中的学习记录博客原作者：K同学啊|接辅导、项目定制Z.心得感受+知识点补充1.ModelCheckpoint讲解函数原型：tf.keras.callbacks.ModelCheckpoint(filepath,monitor='val_loss',verbose=0,save_best_only=False,save_weights_only=False,mode='a
第T4周：使用TensorFlow实现猴痘病识别 oufoc tensorflow 人工智能 python
本文为365天深度学习训练营中的学习记录博客原作者：K同学啊文章目录一、前期工作1.设置GPU（如果使用的是CPU可以忽略这步）2.导入数据3.查看数据二、数据预处理1、加载数据2、数据可视化3、再次检查数据4、配置数据集三、构建CNN网络四、编译五、训练模型六、模型评估1.Loss与Accuracy图2.指定图片进行预测七、优化1、使用`model.evaluate`使用测试集评估模型2、网络结
文件切片上传-仅学习记录 qq_41562817 Vue vue.js javascript
一、目的：本文仅记录一次实践尝试，仅前端调试成功，后端未反馈问题，不过后来接口废弃了。二、前期博客浏览参考：本文链接：文件分片上传【前端】_分片上传原理-CSDN博客本文链接：前端大文件切片上传，断点续传、秒传等解决方案，vue中使用实例，react同理_前端文件切片_刘伟坤的博客-CSDN博客原文链接：前端大文件上传优化方案——分片上传-知乎三、原理：分片上传的整个流程大致如下：(1)将需要上传
hive学习记录 2302_80695227 hive 学习 hadoop
一、Hive的基本概念定义：Hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张表，并提供类SQL查询功能。Hive将HQL（HiveQueryLanguage）转化成MapReduce程序或其他分布式计算引擎（如Tez、Spark）的任务进行计算。数据存储：Hive处理的数据存储在HDFS（HadoopDistributedFileSystem）上。执行引擎：Hive的
双证班学习记录2-开营糖糖82
听完开营课，觉得樊老师这个课程设置主打一个认真努力，愿意坚持和突破，而且奖励颇多，这无形中让我增强了学完的信心，挺好。开营后要对2个月学习做宣誓，我发了文字，但觉得还是得抓住每个锻炼的机会，于是又录视频，这次面对镜头没有那么多顾忌了，也不太在意自己录的是否好了，就纯粹觉得自己要对自己立个flag，鼓励自己坚持走完2个月的学习内容，不轻易畏难放弃。就像宣誓说的，多行动，多参与，所以我要抓住每一个自己
Vue3学习记录——(1)MVC与MVVM 一只漫步前行的羊 Vue3学习记录 vue.js 学习 mvc
1.传统的MVC模式模型（Model）：数据存储。视图（View）：用户界面。控制器（Controller）：业务逻辑。Model代表数据存储，主要用于实现数据的持久化；View代表用户界面（UI），主要用于实现页面的显示；Controller代表业务逻辑，串联起View和Model1.流行的MVVM模式模型（Model）：数据存储。视图（View）：用户界面。视图模型（ViewModel）：数据
时序预测相关论文阅读笔记能力越小责任越小YA 论文阅读笔记时序预测 Transformer
笔记链接：【有道云笔记】读论文（记录）https://note.youdao.com/s/52ugLbot用于个人学习记录。
C语言学习记录4 XSR_yeah 学习
今日学习了注释和对于条件语句和和循环语句的初识：1.注释：用于解释代码。两种方式：1.代码前加//2.在被注释代码上一行加/*，在被注释代码下一行加*/。（C语言的注释不支持嵌套）2.初始条件语句与循环语句：两者与python语句相似，条件语句用if和else，循环语句用for，while,dowhile后面将加快进程，开始着手竞赛准备
第T10周：数据增强 OreoCC 深度学习人工智能 tensorflow2
>-**本文为[365天深度学习训练营]中的学习记录博客**>-**原作者：[K同学啊]**第10周：数据增强难度：夯实基础⭐⭐语言：Python3、TensorFlow2要求：学会在代码中使用数据增强手段来提高acc请探索更多的数据增强手段并记录在本教程中，你将学会如何进行数据增强，并通过数据增强用少量数据达到非常非常棒的识别准确率。我将展示两种数据增强方式，以及如何自定义数据增强方式并将其放到
Activity7框架使用学习记录爱为斯坦项目框架使用学习学习 java
用于记录在项目中使用工作流框架PROC_DEF_ID:流程定义的idbpmn文件中对流程图定义的idTASK_DEF_KEY:任务定义的idbpmn文件中对每个任务定义的idPROC_INST_ID:流程实例id启动一个流程时对流程定义的idPROC_DEF_ID（流程定义的ID）：在BPMN（BusinessProcessModelandNotation）文件中，流程定义的ID是对整个流程图定义
动手学深度学习（pytorch）学习记录20-自定义层[学习记录] walfar pytorch 深度学习 pytorch 学习
在深度学习中，自定义层是指开发者根据特定需求编写的神经网络层，而不是使用深度学习框架（如PyTorch、TensorFlow等）提供的现成层。自定义层可以让模型更加灵活，以适应特定的任务或数据集。目录没有参数的自定义层带参数的层没有参数的自定义层下面的CenteredLayer类要从其输入中减去均值。要构建它，只需继承基础层类并实现前向传播功能。importtorchimporttorch.nn.
动手学深度学习（pytorch）学习记录21-读写文件(模型与参数)[学习记录] walfar pytorch 深度学习 pytorch 学习
目录加载和保存张量加载和保存模型参数保存模型的好处众多，涵盖了从开发到部署的整个机器学习生命周期。节省资源：训练模型可能需要大量的时间和计算资源。保存模型可以避免重复训练，从而节省时间和计算资源。快速部署：一旦模型被训练并保存，它可以迅速部署到生产环境中，加速产品上市时间。版本控制：保存不同版本的模型有助于跟踪模型的迭代过程，便于比较和回滚到之前的版本。离线使用：保存的模型可以在没有网络连接的情况
PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 java UI linux PHP android
╔-----------------------------------╗┆
zookeeper admin 笔记 braveCS zookeeper
Required Software 1) JDK>=1.6 2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines 3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘数据和日志目录 1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
Spring配置多个连接池 easterfly spring
项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？ Spring中有关于dataSource的配置： <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" &nb
Mysql 171815164 mysql
例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。 GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI TH GRANT OPTION; 如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
CommonDAO（公共/基础DAO） g21121 DAO
好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。 DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
直言有讳永夜-极光感悟随笔
1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313 精华: “直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
安装CentOS 7 和Win 7后，Win7 引导丢失随便小屋 centos
一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。一、首先具有root 的权限。即进入Terminal后输入命令su，然后输入密码即可二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改 v
Oracle备份与恢复案例 aijuans oracle
Oracle备份与恢复案例一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
JavaEE开源快速开发平台G4Studio v5.0发布無為子
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。访问G4Studio网站 http://www.g4it.org 2013-04-06 发布G4Studio_V5.0版本功能新增 (1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
Oracle显示根据高考分数模拟录取百合不是茶 PL/SQL编程 oracle例子模拟高考录取学习交流
题目要求: 1,创建student表和result表 2,pl/sql对学生的成绩数据进行处理 3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选 1,创建student表,和result表学生信息表; create table student( student_id number primary key,--学生id
优秀的领导与差劲的领导 bijian1013 领导管理团队
责任优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。努力工作优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
js函数在浏览器下的兼容 Bill_chen jquery 浏览器 IE DWR ext
做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同： IE6：node.nextSibling,对于FF是不能识别的； FF：node.nextElementSibling,对于IE是不能识别的；兼容解决方式：var Div = node.nextSibl
【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC) bit1129 垃圾回收
吞吐量与用户线程暂停时间衡量垃圾回收算法优劣的指标有两个：吞吐量越高，则算法越好暂停时间越短，则算法越好首先说明吞吐量和暂停时间的含义。垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
J2EE监听器和过滤器基础白糖_ J2EE
Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。 ServletContex监听器 ServletContex又叫application
博弈AngularJS讲义(16) - 提供者 boyitech js AngularJS api Angular Provider
Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 bylijinnan java
public class CommonSubSequence { /** * 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 * 写一个版本算法复杂度O(N^2)和一个O(N) 。 * * O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。 * O(
sqlserver 2000 无法验证产品密钥 Chen.H sql windows SQL Server Microsoft
在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。这样做, 收到以下错误信息CD KEY的 SQ
[新概念武器]气象战争 comsci
气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织.... 原因如下: 地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
oracle 中 rollup、cube、grouping 使用详解 daizj oracle grouping rollup cube
oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示转自namesliu -- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景 --- ROLLUP ，为了理解分组的成员数量，我增加了分组的计数 COUNT(SAL)
技术资料汇总分享 Dead_knight 技术资料汇总分享
本人汇总的技术资料，分享出来，希望对大家有用。 http://pan.baidu.com/s/1jGr56uE 资料主要包含： Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...) Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...) Ser
初一下学期难记忆单词背诵第一课 dcj3sjt126com english word
could 能够 minute 分钟 Tuesday 星期二 February 二月 eighteenth 第十八 listen 听 careful 小心的，仔细的 short 短的 heavy 重的 empty 空的 certainly 当然 carry 携带；搬运 tape 磁带 basket 蓝子 bottle 瓶 juice 汁，果汁 head 头；头部
截取视图的图片, 然后分享出去 dcj3sjt126com OS Objective-C
OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast. I implemented a category method on UIView to get the vi
MySql重置密码 fanxiaolong MySql重置密码
方法一: 在my.ini的[mysqld]字段加入： skip-grant-tables 重启mysql服务，这时的mysql不需要密码即可登录数据库然后进入mysql mysql>use mysql; mysql>更新 user set password=password('新密码') WHERE User='root'; mysq
Ehcache（03）——Ehcache中储存缓存的方式 234390216 ehcache MemoryStore DiskStore 存储驱除策略
Ehcache中储存缓存的方式目录 1 堆内存（MemoryStore） 1.1 指定可用内存 1.2 驱除策略 1.3 元素过期 2 &nbs
spring mvc中的@propertysource jackyrong spring mvc
在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了： @PropertySource 在spring 3.1中开始引入比如有配置文件 config.properties mongodb.url=1.2.3.4 mongodb.db=hello 则代码中 @PropertySource(&
重学单例模式 lanqiu17 单例 Singleton 模式
最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式静态内部类方式: package test.pattern.singleton.statics; publ
.NET开源核心运行时，且行且珍惜 netcome java .net 开源
背景 2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
使用oscahe缓存技术减少与数据库的频繁交互 Everyday都不同 Web 高并发 oscahe缓存
此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
Spring+Mybatis 手动控制事务 toknowme mybatis
@Override public boolean testDelete(String jobCode) throws Exception { boolean flag = false; &nbs
菜鸟级的android程序员面试时候需要掌握的知识点 xp9802 android
熟悉Android开发架构和API调用掌握APP适应不同型号手机屏幕开发技巧熟悉Android下的数据存储熟练Android Debug Bridge Tool 熟练Eclipse/ADT及相关工具熟悉Android框架原理及Activity生命周期熟练进行Android UI布局熟练使用SQLite数据库；熟悉Android下网络通信机制，S

十次方项目笔记

项目笔记

1.parent父类pom文件依赖控制

2.tensquare-eureka 注册中心

3.tensquare-gateway

4.tensquare-comom

5.tensquare-base 基础微服务

6.JAP条件查询以及JAP分页查询

7.代码生成器的使用

8.tensquare-recruit 招聘微服务

9.tensquare-qa：需求分析及代码生成

10.tensquare-article 文章微服务（redis）

11.tensquare-gathering 活动微服务

12.tensquare_spit吐槽微服务(springdata-mongodb)

13.tensquare-user 用户微服务 用户注册：分析需求及代码生成

14.加密与权限 BCrypt 与 JWT

15.tensquare-spider 爬虫微服务

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

13.tensquare-user 用户微服务用户注册：分析需求及代码生成