程序员Darker
程序员Darker

SAAS-HRM-day9(页面静态化实现)

  • 1. 搭建页面代理模块
    • 1.1 步骤分析
    • 1.2 步骤实现
  • 2. 发布页面架构图
    • 2.1 页面发布生产方
      • 2.1.1 页面静态化服务
      • 2.1.2 页面静态化调用
        • 2.1.2.1 初始化
        • 2.1.2.2 feign文件上传与下载
    • 2.2 页面发布消费方
  • 3. 课程列表页
    • 3.1 需求
      • 3.1.1 入口
      • 3.1.2 需求分析
    • 3.2 实现
      • 3.2.1 主页跳转到列表页
      • 3.2.2 类型所独有面包屑实现
      • 3.2.3 分页列表+高级查询+排序展示功能

1. 搭建页面代理模块

1.1 步骤分析

  1. 创建项目
  2. 导包
  3. 配置application.yml
  4. 入口类
  5. 日志
  6. swagger
  7. 路由
  8. 测试
  9. 抽取交换机和队列常量
  10. 配置RabbitMQ
  11. 配置处理程序（队列的消费者）

1.2 步骤实现

  1. 创建项目
  • hrm_parent
    • hrm_page_agent_parent
      • hrm_page_agent_common
      • hrm_page_agent_client
      • hrm_page_agent_service
  1. 导包
  • hrm_page_agent_common
        
        
            cn.wangningbo.hrm
            hrm_basic_util
            1.0-SNAPSHOT
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
  • hrm_page_agent_client
    
    
        cn.wangningbo.hrm
        hrm_page_agent_common
        1.0-SNAPSHOT
    
    
    
        org.springframework.cloud
        spring-cloud-starter-openfeign
  • hrm_page_agent_service
        
        
            cn.wangningbo.hrm
            hrm_page_agent_common
            1.0-SNAPSHOT
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        
        
        
            io.springfox
            springfox-swagger2
            2.9.2
        
        
        
            io.springfox
            springfox-swagger-ui
            2.9.2
        
        
        
            org.springframework.boot
            spring-boot-starter-amqp
        
        
        
        
            com.alibaba
            fastjson
            1.2.58
        
        
        
            cn.wangningbo.hrm
            hrm_basic_fastdfs_interface
            1.0-SNAPSHOT
        
        
        
            commons-io
            commons-io
            2.4
  1. 配置application.yml

在hrm_page_agent_service配置

server:
  port: 9007
spring:
  application:
    name: hrm-page-agent
rabbitmq:
  host: 127.0.0.1
  port: 5672
  username: guest
  password: guest
  virtualHost: /
  queues:
    routingKey: hrmCourseSite
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    prefer-ip-address: true
  1. 入口类

在hrm_page_agent_service配置

package cn.wangningbo.hrm;

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

@SpringBootApplication
@EnableEurekaClient
public class PageAgent9007Application {
    public static void main(String[] args) {
        SpringApplication.run(PageAgent9007Application.class, args);
    }
}
  1. 日志

在hrm_page_agent_service配置




    
    
    
    
    
    
        
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
        
    

      
    
        
        ${LOG_HOME}/${appName}/${appName}.log
        
        
            
            ${LOG_HOME}/${appName}/${appName}-%d{yyyy-MM-dd}-%i.log
            
            365
            
            
                100MB
            
        
             
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n
  1. swagger

在hrm_page_agent_service配置

package cn.wangningbo.hrm.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class Swagger2 {
 
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                //对外暴露服务的包,以controller的方式暴露,所以就是controller的包.
                .apis(RequestHandlerSelectors.basePackage("cn.wangningbo.hrm.web.controller"))
                .paths(PathSelectors.any())
                .build();
    }


    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("页面代理api")
                .description("页面代理接口文档说明")
                .contact(new Contact("wangningbo", "", "[email protected]"))
                .version("1.0")
                .build();
    }

}
  1. 路由

在zuul的配置文件里配置一下

zuul:
    routes:
        pageAgent.serviceId: hrm-page-agent # 服务名
        pageAgent.path: /pageAgent/** # 把pageAgent打头的所有请求都转发给hrm-page-agent

在zuul的config包下配置一下

resources.add(swaggerResource("页面代理系统", "/services/pageAgent/v2/api-docs", "2.0"));

最终结果

package cn.wangningbo.hrm.config;

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import springfox.documentation.swagger.web.SwaggerResource;
import springfox.documentation.swagger.web.SwaggerResourcesProvider;

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

@Component
@Primary
public class DocumentationConfig implements SwaggerResourcesProvider {
    @Override
    public List get() {
        List resources = new ArrayList<>();
        //通过网关访问服务地址
        resources.add(swaggerResource("系统管理", "/services/sysmanage/v2/api-docs", "2.0"));
        resources.add(swaggerResource("课程中心", "/services/course/v2/api-docs", "2.0"));
        resources.add(swaggerResource("分布式文件系统", "/services/fastdfs/v2/api-docs", "2.0"));
        resources.add(swaggerResource("分布式全文检索", "/services/es/v2/api-docs", "2.0"));
        resources.add(swaggerResource("redis中央缓存", "/services/redis/v2/api-docs", "2.0"));
        resources.add(swaggerResource("页面管理系统", "/services/page/v2/api-docs", "2.0"));
        resources.add(swaggerResource("页面代理系统", "/services/pageAgent/v2/api-docs", "2.0"));
        return resources;
    }

    private SwaggerResource swaggerResource(String name, String location, String version) {
        SwaggerResource swaggerResource = new SwaggerResource();
        swaggerResource.setName(name);
        swaggerResource.setLocation(location);
        swaggerResource.setSwaggerVersion(version);
        return swaggerResource;
    }
}

  1. 测试

    启动项目，测试swagger是否成功

  2. 抽取交换机和队列常量

在公共模块hrm_basic_parent下新建子模块hrm_basic_rabbitmq

配置常量

package cn.wangningbo.hrm.config;

/**
 * 抽取常量
 */
public class RabbitmqConstants {
    // 交换机常量
    public static final String EXCHANGE_DIRECT_INFORM = "exchange_direct_inform";
    // 队列常量
    public static final String QUEUE_INFORM_PAGESTATIC = "queue_inform_pageStatic";
}
  1. 配置RabbitMQ

在hrm_page_agent_service的pom里面依赖抽取的常量模块

        
            cn.wangningbo.hrm
            hrm_basic_rabbitmq
            1.0-SNAPSHOT

在hrm_page_agent_service配置RabbitMQ

package cn.wangningbo.hrm.config;


import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 主站
 * 课程管理
 * 职位管理
 */
@Configuration
public class RabbitmqConfig {

    @Value("${rabbitmq.queues.routingKey}")
    public  String routingKey;
    public static final String EXCHANGE_DIRECT_INFORM = RabbitmqConstants.EXCHANGE_DIRECT_INFORM;
    public static final String QUEUE_INFORM_PAGESTATIC = RabbitmqConstants.QUEUE_INFORM_PAGESTATIC;

    /**
     * 交换机配置
     * ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
     *
     * @return the exchange
     */
    @Bean(EXCHANGE_DIRECT_INFORM)
    public Exchange exchange_direct_inform() {
    //durable(true)持久化，消息队列重启后交换机仍然存在
        return ExchangeBuilder.directExchange(EXCHANGE_DIRECT_INFORM).durable(true).build();
    }

    //声明队列
    @Bean(QUEUE_INFORM_PAGESTATIC) //交给spring管理的bean的名字可以随便的
    public Queue pageStaticQueue() {
        Queue queue = new Queue(QUEUE_INFORM_PAGESTATIC); //队列名
        return queue;
    }

    //    Qualifier//获取特定名称bean
    @Bean
    public Binding BINDING_QUEUE_INFORM_HRMJOBSITE(@Qualifier(QUEUE_INFORM_PAGESTATIC) Queue queue,
                                              @Qualifier(EXCHANGE_DIRECT_INFORM) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(routingKey).noargs();
    }


    public String getRoutingKey() {
        return routingKey;
    }

    public void setRoutingKey(String routingKey) {
        this.routingKey = routingKey;
    }
}
  1. 配置处理程序（队列的消费者）

改造fastdfs的下载方法

FastDFSClient

    /**
     * 下载
     *
     * @param path
     */
    @GetMapping(value = "/download", consumes = MediaType.APPLICATION_JSON_UTF8_VALUE)
    //直接把流写到Response // 注意：这个Response是feign的
    Response download(@RequestParam("path") String path);

FastDFSClientHystrixFallbackFactory

package cn.wangningbo.hrm.client;

import cn.wangningbo.hrm.util.AjaxResult;
import feign.Response;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

@Component
public class FastDFSClientHystrixFallbackFactory implements FallbackFactory {
    @Override
    public FastDFSClient create(Throwable throwable) {
        return new FastDFSClient() {
            @Override
            public String upload(MultipartFile file) {
                return null;
            }

            @Override
            public AjaxResult delete(String path) {
                return null;
            }

            @Override
            public Response download(String path) {
                return null;
            }
        };
    }
}

在hrm_page_agent_service配置处理程序

package cn.wangningbo.hrm.handler;

import cn.wangningbo.hrm.client.FastDFSClient;
import cn.wangningbo.hrm.config.RabbitmqConstants;
import com.alibaba.fastjson.JSONObject;
import com.rabbitmq.client.Channel;
import feign.Response;
import org.apache.commons.io.IOUtils;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

@Component
public class StaticPageDownloadHandler {

    @Autowired
    private FastDFSClient fastDFSClient;

    @RabbitListener(queues = RabbitmqConstants.QUEUE_INFORM_PAGESTATIC)
    public void receiveHomeSite(String msg, Message message, Channel channel) {
        //msg -fileSysType,staticPageUrl,physicalPath
        JSONObject jsonObject = JSONObject.parseObject(msg);
        Integer fileSysType = jsonObject.getInteger("fileSysType");
        String staticPageUrl = jsonObject.getString("staticPageUrl");
        String physicalPath = jsonObject.getString("physicalPath");
        System.out.println(staticPageUrl);
        System.out.println(physicalPath);

        switch (fileSysType) {
            case 0: //fastdfs
                System.out.println("[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[");
                fastDfsDownloadAndCopy(staticPageUrl, physicalPath);
                break;
            case 1: //hdfs
                hdfsDownloadAndCopy(staticPageUrl, physicalPath);
                break;
            default:
                break;
        }
    }
    /**
     * 通过fastdfs下载文件,并且拷贝到特定的目录
     * @param staticPageUrl
     * @param physicalPath
     */
    private void hdfsDownloadAndCopy(String staticPageUrl, String physicalPath) {

        //@TODO
    }

    /**
     * 通过fastdfs下载文件,并且拷贝到特定的目录
     * @param staticPageUrl
     * @param physicalPath
     */
    private void fastDfsDownloadAndCopy(String staticPageUrl, String physicalPath) {
        System.out.println(staticPageUrl+"=====================================staticPageUrl");
        System.out.println(physicalPath+"-----------------------------------------physicalPath");
        Response response = fastDFSClient.download(staticPageUrl);
        System.out.println("pppppppppppppppppp||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||");
        InputStream is = null;
        OutputStream os = null;
        try {
            is  = response.body().asInputStream();
            os = new FileOutputStream(physicalPath);
            IOUtils.copy(is,os);
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2. 发布页面架构图

[图片上传失败...(image-ceee53-1569803685569)]
技术方案说明：

  1. 平台包括多个站点，页面归属不同的站点。
  2. 发布一个页面应将该页面发布到所属站点的服务器上。
  3. 每个站点服务部署cms client程序，并与交换机绑定，绑定时指定站点Id为routingKey。 指定站点id为routingKey就可以实现cms client只能接收到所属站点的页面发布消息。
  4. 页面发布程序向MQ发布消息时指定页面所属站点Id为routingKey，将该页面发布到它所在服务器上的cms client。

路由模式分析如下：

发布一个页面，需发布到该页面所属的每个站点服务器，其它站点服务器不发布。

比如：发布一个门户的页面，需要发布到每个门户服务器上，而用户中心服务器则不需要发布。 所以本项目采用routing模式，用站点id作为routingKey，这样就可以匹配页面只发布到所属的站点服务器上。

页面发布流程图如下：
[图片上传失败...(image-9ea392-1569803685569)]

2.1 页面发布生产方

2.1.1 页面静态化服务

hrm_page_service的最终导包情况

        
        
            cn.wangningbo.hrm
            hrm_page_common
            1.0-SNAPSHOT
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        
        
        
            com.baomidou
            mybatis-plus-boot-starter
            2.2.0
        
        
        
            mysql
            mysql-connector-java
        
        
        
            org.springframework.cloud
            spring-cloud-starter-config
        
        
        
            io.springfox
            springfox-swagger2
            2.9.2
        
        
        
            io.springfox
            springfox-swagger-ui
            2.9.2
        
        
        
            cn.wangningbo.hrm
            hrm_basic_redis_client
            1.0-SNAPSHOT
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
            cn.wangningbo.hrm
            hrm_basic_fastdfs_interface
            1.0-SNAPSHOT
        
        
        
            commons-io
            commons-io
            2.4
        
        
            org.apache.velocity
            velocity
            1.7
        
        
            commons-fileupload
            commons-fileupload
            1.3.1
        
        
            cn.wangningbo.hrm
            hrm_basic_rabbitmq
            1.0-SNAPSHOT
  1. client
    /**
     * 静态化页面
     * @param map
     * @return
     */
    @PostMapping("/staticPage")
    AjaxResult staticPage(Map map);
  1. HystrixFallbackFactory暂时不做处理
            @Override
            public AjaxResult staticPage(Map map) {
                return null;
            }
  1. controller
    /**
     * 静态化页面
     * @param map
     * @return
     */
    @PostMapping("/staticPage")
    AjaxResult staticPage(@RequestBody Map map){
        String dataKey = map.get("dataKey");
        String pageName = map.get("pageName");
        try {
            pageConfigService.staticPage(dataKey,pageName);
            return AjaxResult.me();
        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.me().setSuccess(false).setMessage("静态化失败!"+e.getMessage());
        }
    }
  1. IService
    void staticPage(String dataKey, String pageName);
  1. ServiceImpl

修改fastdfs的上传：client

    @PostMapping(value="/upload", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE}
            , consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    String upload(@RequestPart("file") MultipartFile file);

修改fastdfs的上传：controller

    /**
     * 上传
     *
     * @param file
     * @return
     */
    @PostMapping(value = "/upload", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE}
            , consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public String upload(@RequestPart("file") MultipartFile file) {
        try {
            String fileName = file.getOriginalFilename(); // 1.png
            String extName = fileName.substring(fileName.lastIndexOf(".") + 1);
            System.out.println(extName);
            return FastDfsApiOpr.upload(file.getBytes(), extName);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("error...." + e.getMessage());
        }
        return null;
    }

压缩包工具ZipUtil

package cn.wangningbo.hrm.util;

import java.io.*;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

/**
 *  
 * @version 1.0 
 * @since 2015-9-14 
 * 文件解压缩工具类 
 * 
 */  
public final class ZipUtil  
{  
  
    /** 
     * 缓冲大小 
     */  
    private static int BUFFERSIZE = 2 << 10;  
      
    /** 
     * 压缩 
     * @param paths 
     * @param fileName 
     */  
    public static void zip(String[] paths, String fileName)  
    {  
          
        ZipOutputStream zos = null;
        try  
        {  
            zos = new ZipOutputStream(new FileOutputStream(fileName));
            for(String filePath : paths)  
            {  
                //递归压缩文件  
                File file = new File(filePath);  
                String relativePath = file.getName();  
                if(file.isDirectory())  
                {  
                    relativePath += File.separator;
                }  
                zipFile(file, relativePath, zos);  
            }  
        }  
        catch (IOException e)
        {  
            e.printStackTrace();  
        }  
        finally  
        {  
            try  
            {  
                if(zos != null)  
                {  
                    zos.close();  
                }  
            }  
            catch (IOException e)  
            {  
                e.printStackTrace();  
            }  
        }  
    }  
      
    public static void zipFile(File file, String relativePath, ZipOutputStream zos)  
    {  
        InputStream is = null;
        try  
        {  
            if(!file.isDirectory())  
            {  
                ZipEntry zp = new ZipEntry(relativePath);
                zos.putNextEntry(zp);  
                is = new FileInputStream(file);
                byte[] buffer = new byte[BUFFERSIZE];  
                int length = 0;  
                while ((length = is.read(buffer)) >= 0)  
                {  
                    zos.write(buffer, 0, length);  
                }  
                zos.flush();  
                zos.closeEntry();  
            }  
            else  
            {  
                for(File f: file.listFiles())  
                {  
                    zipFile(f, relativePath + f.getName() + File.separator, zos);  
                }  
            }  
        }  
        catch (IOException e)  
        {  
            e.printStackTrace();  
        }  
        finally  
        {  
            try  
            {  
                if(is != null)  
                {  
                    is.close();  
                }  
            }  
            catch (IOException e)  
            {  
                e.printStackTrace();  
            }  
        }  
    }  
      
    /** 
     * 解压缩 
     * @param fileName 
     * @param path 
     */  
    public static void unzip(String fileName, String path)  
    {  
        FileOutputStream fos = null;  
        InputStream is = null;  
        try  
        {  
            ZipFile zf = new ZipFile(new File(fileName));
            Enumeration en = zf.entries();
            while (en.hasMoreElements())  
            {  
                ZipEntry zn = (ZipEntry) en.nextElement();  
                if (!zn.isDirectory())  
                {  
                    is = zf.getInputStream(zn);  
                    File f = new File(path + zn.getName());  
                    File file = f.getParentFile();  
                    file.mkdirs();  
                    fos = new FileOutputStream(path + zn.getName());  
                    int len = 0;  
                    byte bufer[] = new byte[BUFFERSIZE];  
                    while (-1 != (len = is.read(bufer)))  
                    {  
                        fos.write(bufer, 0, len);  
                    }  
                    fos.close();  
                }  
            }  
        }  
        catch (ZipException e)
        {  
            e.printStackTrace();  
        }  
        catch (IOException e)  
        {  
            e.printStackTrace();  
        }  
        finally  
        {  
            try  
            {  
                if(null != is)  
                {  
                    is.close();  
                }  
                if(null != fos)  
                {  
                    fos.close();  
                }  
            }  
            catch (IOException e)  
            {  
                e.printStackTrace();  
            }  
        }  
    }  
      
    /** 
     * @param args 
     */  
    public static void main(String[] args)  
    {  
        //zip(new String[] {"D:/tmp/20150418/logs/file/2015-08-28/debug-log.log","D:/tmp/20150418/logs/file/2015-08-28/error-log.log"}, "D:/tmp/20150418/logs/file/2015-08-28/test.zip");
        //unzip("D://tmep.zip", "D:/temp/");

        Map modelMap = new HashMap<>(); //封装两个参数作为一个对象传入进去
        String templatePagePath = "D://temp/home.vm.html"; //本地静态页面地址
        String staticRoot = "D://temp/";
        modelMap.put("staticRoot", staticRoot);
        modelMap.put("courseTypes", null);
        VelocityUtils.staticByTemplate(modelMap,"D://temp/home.vm",templatePagePath); //进行页面静态化
    }  
}

页面静态化工具

package cn.wangningbo.hrm.util;

import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.app.VelocityEngine;

import java.io.*;
import java.util.Properties;

public class VelocityUtils {
    private static Properties p = new Properties();
    static {
        p.setProperty(Velocity.FILE_RESOURCE_LOADER_PATH, "");
        p.setProperty(Velocity.ENCODING_DEFAULT, "UTF-8");
        p.setProperty(Velocity.INPUT_ENCODING, "UTF-8");
        p.setProperty(Velocity.OUTPUT_ENCODING, "UTF-8");
    }
    
    /**
     * 返回通过模板，将model中的数据替换后的内容
     * @param model
     * @param templateFilePathAndName
     * @return
     */
    public static String getContentByTemplate(Object model, String templateFilePathAndName){
        try {
            Velocity.init(p);
            Template template = Velocity.getTemplate(templateFilePathAndName);
            VelocityContext context = new VelocityContext();
            context.put("model", model);
            StringWriter writer = new StringWriter();
            template.merge(context, writer);
            String retContent = writer.toString();
            writer.close();
            return retContent;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 根据模板，静态化model到指定的文件 模板文件中通过访问model来访问设置的内容
     * 
     * @param model
     *            数据对象
     * @param templateFilePathAndName
     *            模板文件的物理路径
     * @param targetFilePathAndName
     *            目标输出文件的物理路径
     */
    public static void staticByTemplate(Object model, String templateFilePathAndName, String targetFilePathAndName) {
        try {
            Velocity.init(p);
            Template template = Velocity.getTemplate(templateFilePathAndName);
            
            VelocityContext context = new VelocityContext();
            context.put("model", model);
            FileOutputStream fos = new FileOutputStream(targetFilePathAndName);
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(fos, "UTF-8"));// 设置写入的文件编码,解决中文问题
            template.merge(context, writer);
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 静态化内容content到指定的文件
     * 
     * @param content
     * @param targetFilePathAndName
     */
    public static void staticBySimple(Object content, String targetFilePathAndName) {
        VelocityEngine ve = new VelocityEngine();
        ve.init(p);
        String template = "${content}";
        VelocityContext context = new VelocityContext();
        context.put("content", content);
        StringWriter writer = new StringWriter();
        ve.evaluate(context, writer, "", template);
        try {
            FileWriter fileWriter = new FileWriter(new File(targetFilePathAndName));
            fileWriter.write(writer.toString());
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

ServiceImpl

package cn.wangningbo.hrm.service.impl;


import cn.wangningbo.hrm.client.FastDFSClient;
import cn.wangningbo.hrm.client.RedisClient;
import cn.wangningbo.hrm.config.RabbitmqConstants;
import cn.wangningbo.hrm.domain.PageConfig;
import cn.wangningbo.hrm.domain.Pager;
import cn.wangningbo.hrm.domain.Site;
import cn.wangningbo.hrm.dto.CourseTypeDto;
import cn.wangningbo.hrm.mapper.PageConfigMapper;
import cn.wangningbo.hrm.mapper.PagerMapper;
import cn.wangningbo.hrm.mapper.SiteMapper;
import cn.wangningbo.hrm.service.IPageConfigService;
import cn.wangningbo.hrm.util.VelocityUtils;
import cn.wangningbo.hrm.util.ZipUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import feign.Response;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.io.IOUtils;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import java.io.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 

 * 服务实现类
 * 

 *
 * @author wangningbo
 * @since 2019-09-09
 */
@Service
public class PageConfigServiceImpl extends ServiceImpl implements IPageConfigService {
    @Autowired
    private PagerMapper pagerMapper;
    @Autowired
    private FastDFSClient fastDFSClient;
    @Autowired
    private RedisClient redisClient;
    @Autowired
    private PageConfigMapper pageConfigMapper;
    @Autowired
    private SiteMapper siteMapper;
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Override
    public void staticPage(String dataKey, String pageName) {
        //一、页面静态化
        // 根据name去数据库中查询name记录，获取到第一个
        Pager pager = pagerMapper.selectList(new EntityWrapper().eq("name", pageName)).get(0);
        // 获取到fastdfs中模板压缩包的路径
        String templateUrl = pager.getTemplateUrl();
        // 获取要执行的模板文件
        String templateName = pager.getTemplateName();
        // 下载fastdfs上面的模板压缩包
        Response response = fastDFSClient.download(templateUrl);
        InputStream inputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            //获得输入流资源
            inputStream = response.body().asInputStream();
            // 所有静态化中数据都写入操作系统的临时目录（这个可以跨操作系统，而且临时目录的东西会自动维护，无需手动删除）
            String tempdir = System.getProperty("java.io.tmpdir");
            System.out.println(tempdir + "-------------------------------临时目录");
            // 要下载压缩包的路径
            String zipPath = tempdir + "/temp.zip";
            // 要解压到的路径
            String unZipPath = tempdir + "/temp/";
            // 获得输出流资源
            fileOutputStream = new FileOutputStream(zipPath);
            // 保存到本地 //import org.apache.commons.io.IOUtils;
            IOUtils.copy(inputStream, fileOutputStream); //保存到本地

            // 解压缩
            ZipUtil.unzip(zipPath, unZipPath);
            // 获取到模板 //模板路径 temp/home.vm
            String templatePath = unZipPath + "/" + templateName;
            System.out.println(templatePath + "-----------------------------------模板路径");
            // 获取到生成生成静态页面的路径 //本地静态页面的地址
            String templatePagePath = templatePath + ".html";
            System.out.println(templatePagePath + "----------------------------------本地静态页面的地址");

            // 生成页面需要的数据 //从redis中获取
            String courseTypes = redisClient.get("courseTypes");
            // json字符串转list
            List courseTypeDtos = JSONArray.parseArray(courseTypes, CourseTypeDto.class);
            // 封装两个参数成一个对象传入进去
            HashMap map = new HashMap<>();
            map.put("staticRoot", unZipPath);
            map.put("courseTypes", courseTypeDtos);

            // 进行页面静态化
            VelocityUtils.staticByTemplate(map, templatePath, templatePagePath);
            // 传递到fastdfs
            String pageUrl = fastDFSClient.upload(
                    new CommonsMultipartFile(createFileItem(new File(templatePagePath), "file")));

            // 二 PageConfig 并且进行保存
            PageConfig config = new PageConfig();
            config.setTemplateUrl(templateUrl);
            config.setTemplateName(templateName);
            config.setDataKey(dataKey);
            config.setPhysicalPath(pager.getPhysicalPath());
            config.setDfsType(0L); //0表示fastDfs
            config.setPageUrl(pageUrl);
            config.setPageId(pager.getId());
            pageConfigMapper.insert(config);

            // 三、往消息队列放入消息
            String routingKey = siteMapper
                    .selectList(new EntityWrapper().eq("id", pager.getSiteId())).get(0).getSn();
            System.out.println(routingKey + "----------------------------routingKey");
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("fileSysType", 0);
            jsonObject.put("staticPageUrl", pageUrl);
            jsonObject.put("physicalPath", pager.getPhysicalPath());
            System.out.println(jsonObject.toJSONString() + "---------------------------------------------jsonObject.toJSONString()");
            rabbitTemplate.convertAndSend(
                    RabbitmqConstants.EXCHANGE_DIRECT_INFORM, routingKey, jsonObject.toJSONString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 创建FileItem
     *
     * @param file
     * @param filedName
     * @return
     */
    private FileItem createFileItem(File file, String filedName) {
        FileItemFactory factory = new DiskFileItemFactory(16, null);
        FileItem item = factory.createItem(filedName, "text/plain", true, file.getName());
        int bytesRead = 0;
        byte[] buffer = new byte[8192];
        try {
            FileInputStream fis = new FileInputStream(file);
            OutputStream os = item.getOutputStream();
            while ((bytesRead = fis.read(buffer, 0, 8192)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            os.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return item;
    }
}

2.1.2 页面静态化调用

2.1.2.1 初始化

IService

    /**
     *初始化课程站点主页
     */
    void InitCourseSiteIndex();

ServiceImpl

    @Override
    public void InitCourseSiteIndex() {
        //1 准备模板,并且上传fastdfs
        //2存放数据到redis
        List courseTypes = queryTypeTree(0L);
        String dataKey = "courseTypes";
        redisClient.set(dataKey, JSONArray.toJSONString(courseTypes));
        //3调用静态化接口产生静态页面,并且放入fastdfs
        String pageName = "CourseIndex";
        //本来应该通过PageName获取page后设置pageconfig传递,由于数据在查询端,还不如直接传入pageName到那边查询.
        Map map = new HashMap<>();
        map.put("dataKey",dataKey);
        map.put("pageName",pageName);
        pageConfigClient.staticPage(map);
        //4往消息队列放一个消息,让pageAgent来下载静态页面
    }

2.1.2.2 feign文件上传与下载

参考文档：Feign文件上传与下载.md
链接：http://note.youdao.com/noteshare?id=b3a62850f8b259a0fbc14b40b46288b7&sub=08937A6337FD44DBBB3BF9C4C1839436

2.2 页面发布消费方

新建公共模块抽取常量

导包

        
        
            org.springframework.boot
            spring-boot-starter-amqp

抽取常量

package cn.wangningbo.hrm.config;

/**
 * 抽取常量
 */
public class RabbitmqConstants {
    // 交换机常量
    public static final String EXCHANGE_DIRECT_INFORM = "exchange_direct_inform";
    // 队列常量
    public static final String QUEUE_INFORM_PAGESTATIC = "queue_inform_pageStatic";
}

3. 课程列表页

3.1 需求

3.1.1 入口

  1. 主页里面关键字搜索
  2. 主页里面通过类型导航过去.

3.1.2 需求分析

  1. 主页里面关键字搜索

    • 分页查询+排序 select name from t_user where name like xxx order by limit 0,10

  2. 主页里面通过类型导航过去.

    • 有面包屑
    • 有品牌
    • 分页查询+排序 select name from t_user where name like xxx order by limit 0,10

3.2 实现

3.2.1 主页跳转到列表页

分析：

  1. 主页携带参数跳转到列表页.
    location.href = list.html?keyword=xx
    location.href = list.html?productType=154
  2. 列表页,加载完毕后,获取传递过来keyword ,或者productType
    • keyword
      • ①回显搜索框
      • ②以keyword为搜索条件到es中查询分页数据,展示在界面
    • productType
      • ①发送获取面包屑请求,展示在界面
      • ②发送品牌请求获取品牌,展示在界面
      • ②以productType为搜索条件到es中查询分页数据,展示在界面

实现：

3.2.2 类型所独有面包屑实现

  1. 结构分析

根据当前类型获取层级关系,并且每一级都有自己及其兄弟. List>
每一级有一个Map表示,里面有两个值,一个是ProductType ower;一个是List otherProductTypes.

  1. 后台接口

配置跨域

        config.addAllowedOrigin("http://127.0.0.1:6002");
        config.addAllowedOrigin("http://localhost:6002");

controller

    /**
     *  通过类型查询面包屑数据
     *     有层次(Node): path
     *     Node: 自己和兄弟  path里面就是自己 通过自己查询父亲,再通过父亲找到儿子,删除自己就ok
     * @return
     */
    @RequestMapping(value = "/crumbs",method = RequestMethod.GET)
    public List> getCrumbs(Long courseTypeId){
        return courseTypeService.getCrumbs(courseTypeId);
    }

IService

    List> getCrumbs(Long courseTypeId);

ServiceImpl

    @Override
    public List> getCrumbs(Long courseTypeId) {
        List> result = new ArrayList<>();
        //1 获取path 1.2.3
        CourseType courseType = courseTypeMapper.selectById(courseTypeId);
        String path = courseType.getPath();

        //2 截取path中各个节点自己  1 2 3
        String[] paths = path.split("\\.");

        //3 获取自己节点兄弟封装Map,放入List中进行返回
        for (String ownerIdStr : paths) {
            Map map = new HashMap<>();

            Long ownerId = Long.valueOf(ownerIdStr);

            System.out.println(ownerId);
            //获取每个自己
            CourseType owner =  courseTypeMapper.selectById(ownerId);
            map.put("owner",owner);
            //查询兄弟
            //获取父亲所有儿子
            List allChildren = courseTypeMapper
                    .selectList(new EntityWrapper().eq("pid",owner.getPid()));

            //干掉自己-边遍历边操作(正删改),要用迭代器
            Iterator iterator = allChildren.iterator();
            while (iterator.hasNext()){
                CourseType currentType = iterator.next();
                if (currentType.getId().longValue()==owner.getId().longValue()){
                    iterator.remove();
                    continue; //跳出当前循环
                }
            }
            map.put("otherCourseTypes",allChildren);
            result.add(map);
        }
        return result;
    }

3.2.3 分页列表+高级查询+排序展示功能

es的client

    /**
     * 从es中查询
     * @param params
     * @return
     */
    @PostMapping("/query")
    PageList> query(@RequestBody Map params);

HystrixFallbackFactory先不做处理

            @Override
            public PageList> query(Map params) {
                return null;
            }

es的controller

    @PostMapping("/query")
    PageList> query(@RequestBody Map params) {
        return esCourseService.query(params);
    }

es的IService

    PageList> query(Map params);

es的ServiceImpl

    @Override
    public PageList> query(Map params) {
        // keyword CourseyType brandId priceMin priceMax sortField sortType page rows
        String keyword = (String) params.get("keyword"); //查询
        String sortField = (String) params.get("sortField"); //排序
        String sortType = (String) params.get("sortType");//排序

        Long courseType = params.get("CourseType") != null ? Long.valueOf(params.get("CourseType").toString()) : null;//过滤
        Long priceMin = params.get("priceMin") != null ? Long.valueOf(params.get("priceMin").toString()) * 100 : null;//过滤
        Long priceMax = params.get("priceMax") != null ? Long.valueOf(params.get("priceMax").toString()) * 100 : null;//过滤
        Long page = params.get("page") != null ? Long.valueOf(params.get("page").toString()) : null; //分页
        Long rows = params.get("rows") != null ? Long.valueOf(params.get("rows").toString()) : null;//分页

        //构建器
        NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
        //设置查询条件=查询+过滤
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        if (StringUtils.isNotBlank(keyword)) {
            boolQuery.must(QueryBuilders.matchQuery("all", keyword));
        }
        List filter = boolQuery.filter();
        if (courseType != null) { //类型
            filter.add(QueryBuilders.termQuery("courseTypeId", courseType));
        }
        //最大价格 最小价格
        //minPrice <= priceMax && maxPrice>=priceMin
        if (priceMax != null && priceMin != null) {
            filter.add(QueryBuilders.rangeQuery("price").gte(priceMin).lte(priceMax));
        }
        builder.withQuery(boolQuery);
        //排序
        SortOrder defaultSortOrder = SortOrder.DESC;
        if (StringUtils.isNotBlank(sortField)) {//销量 新品 价格 人气 评论
            //如果传入的不是降序改为升序
            if (StringUtils.isNotBlank(sortType) && !sortType.equals(SortOrder.DESC)) {
                defaultSortOrder = SortOrder.ASC;
            }
            // 价格  索引库有两个字段 最大,最小
            //如果用户按照升序就像买便宜的,就用最小价格,如果用户按照降序想买贵的,用最大价格
            if (sortField.equals("jg")) {
                builder.withSort(SortBuilders.fieldSort("price").order(defaultSortOrder));
            }
        }
        //分页
        Long pageTmp = page - 1; //从0开始
        builder.withPageable(PageRequest.of(pageTmp.intValue(), rows.intValue()));
        //截取字段 @TODO
        //封装数据
        Page CourseDocs = courseRepository.search(builder.build());
        List> datas = esCourses2ListMap(CourseDocs.getContent());
        return new PageList<>(CourseDocs.getTotalElements(), datas);
    }

    /**
     * 数据转换
     *
     * @param content
     * @return
     */
    private List> esCourses2ListMap(List content) {
        List> result = new ArrayList<>();
        for (ESCourse esCourse : content) {
            result.add(esCourse2Map(esCourse));
        }
        return result;
    }

    private Map esCourse2Map(ESCourse esCourse) {
        Map result = new HashMap<>();
        result.put("id", esCourse.getId());
        result.put("name", esCourse.getName());
        result.put("users", esCourse.getUsers());
        result.put("courseTypeId", esCourse.getCourseTypeId());
        result.put("courseTypeName", esCourse.getCourseTypeName());
        result.put("gradeId", esCourse.getGradeId());
        result.put("gradeName", esCourse.getGradeName());
        result.put("status", esCourse.getStatus());
        result.put("tenantId", esCourse.getTenantId());
        result.put("tenantName", esCourse.getTenantName());
        result.put("userId", esCourse.getUserId());
        result.put("userName", esCourse.getUserName());
        result.put("startTime", esCourse.getStartTime());
        result.put("endTime", esCourse.getEndTime());
        result.put("expires", esCourse.getExpires());
        result.put("priceOld", esCourse.getPriceOld());
        result.put("price", esCourse.getPrice());
        result.put("intro", esCourse.getIntro());
        result.put("qq", esCourse.getQq());
        result.put("resources", esCourse.getResources());
        return result;
    }

高级搜索的controller

    @PostMapping("/queryCourses")
    public PageList> queryCourses(@RequestBody Map query){
        return courseService.queryCourses(query);
    }

IService

    PageList> queryCourses(Map query);

ServiceImpl

    /**
     * 高级搜索
     * @param query
     * @return
     */
    @Override
    public PageList> queryCourses(Map query) {
        return esCourseClient.query(query);
    }

你可能感兴趣的:(SAAS-HRM-day9(页面静态化实现))

  • SpringMVC设置全局异常处理器 水岸齐天 javaspring
    文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
  • uni-app实现 步骤条 夏夏的码农 uni-app
    实现如图样式html部分代码如下投资期限与收益0?'active':'default'">募集开始1?'active':'default'">募集结束2?'active':'default'">产品成立3?'active':'default'">产品到期0?'active-step1':'step1'">1?'active-st
  • 手机上赚钱？学会这5种方法！高省app让你轻松赚钱！ 高省浮沉000018
    随着智能手机的普及，越来越多的人开始探索在手机上赚钱的方法。不仅可以利用碎片时间增加收入，还能减少对传统办公室工作的依赖。本文将向您介绍5种在手机上赚钱的方法，并推荐一款高省app，帮助您实现手机赚钱的目标。大家好！我是高省APP最大团队&联合创始人浮沉导师！【高省】APP网购优惠券免费领，分享还能赚钱。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台。佣金更高，模式更好，终端用户不流失。0投资
  • 【算法分析与设计】去除重复字母 五敷有你 算法分析与设计javajavascript开发语言算法数据结构
    个人主页：五敷有你系列专栏：算法分析与设计⛺️稳中求进，晒太阳题目给你一个字符串s，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。示例示例1：输入：s="bcabc"输出："abc"示例2：输入：s="cbacdcbc"输出："acdb"思路贪心+单调栈实现【字符串删除一个字符使其字典序最小的贪心策略】：对于两个长度相同的字符串，
  • 以前开发MFC界面如何快速转成QT界面 广州视觉芯软件有限公司 mfcqtc++
    将MFC界面快速转换为Qt界面可能需要进行一些手动工作，因为MFC和Qt是两个不同的界面框架，它们具有不同的设计和实现原理。但是，以下步骤可以帮助你快速进行转换：创建一个新的Qt项目：使用QtCreator创建一个新的Qt项目。分析MFC界面：仔细分析你的MFC界面，包括窗口、对话框、控件等的布局、样式和行为。重新设计界面：使用Qt的可视化设计器重新设计界面。在QtCreator的设计器中，你可以
  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shirojavajava安全开发语言
    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
  • C#WPF控件TextBlock详解 未来无限 C#WPF程序设计c#wpf控件TextBlock回车换行多行显示强制回车换行
    本文讲解WPF控件TextBlock。目录定义常用属性实例如何实现自动换行？如何强制回车换行？
  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？ 大龄下岗程序员 mysqljavamysqlspring
    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
  • 大创项目推荐 深度学习 opencv python 公式识别(图像识别 机器视觉) laafeer python
    文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
  • 标定系列——基于OpenCV实现普通相机、鱼眼相机不同标定板下的标定（五） JANGHIGH 标定opencv
    标定系列——基于OpenCV实现相机标定（五）说明代码解析VID5.xmlin_VID5.xmlcamera_calibration.cpp说明该程序可以实现多种标定板的相机标定工作代码解析VID5.xmlimages/CameraCalibration/VID5/xx1.jpgimages/CameraCalibration/VID5/xx2.jpgimages/CameraCalibratio
  • 3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb前端ajaxelementuijava前端框架
    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
  • docker基础（一） 运维搬运工 容器-dockerdocker容器运维
    相关概念介绍Docker是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖到一个可移植的容器中，然后发布到任何流行的linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，互相之间不会有任何接口。Docker有几个重要概念：dockerfile，配置文件，用来生成dockerimagedockerimage，交付部署的最小单元docker命令与API，定义命令与接口，支持第三方系统集
  • RabbitMQ 实验消费原始队列消息， 拒绝（reject）投递死信交换机过程 熊明才 rabbitmq分布式
    如果你想通过RabbitMQ的死信队列功能实现消费者拒绝消息投递到死信交换机的行为，你可以按照以下步骤操作：创建原始队列，并将其绑定到一个交换机上：exportRABBITMQ_SERVER=127.0.0.1exportRABBITMQ_PORT=5672exportRABBITMQ_USER=mingcaiexportRABBITMQ_PASSWORD=passwordrabbitmqadmi
  • 掌握Flutter底部导航栏：畅游导航之旅 繁依Fanyi xmljsonsqlflutter开发语言前端git
    1.引言在移动应用开发中，底部导航栏是一种常见且非常实用的用户界面元素。它提供了快速导航至不同功能模块或页面的便捷方式，使用户可以轻松访问应用程序的各个部分。在Flutter中，底部导航栏也是一项强大的功能，开发者可以利用Flutter框架提供的丰富组件和灵活性，轻松实现各种样式和交互效果的底部导航栏。本文将深入探讨Flutter中底部导航栏的实现方法，从基础的结构搭建到高级功能的应用，带领读者逐
  • 排序算法太多？常用排序都在这了，一篇文章总结和实现所有面试会考的排序算法（基于Python实现） 宇宙之一粟 不归路之Python#IT面试题收集与总结数据结构与算法算法数据结构排序算法pythonjava
    文章目录排序算法1.常见的排序算法1.1选择排序1.1.1思想1.1.2实现**1.1.3选择排序分析**1.2冒泡排序**1.2.1思想****1.2.2实现****1.2.3冒泡排序分析**1.3插入排序**1.3.1思想****1.3.2实现****1.3.3插入排序分析**1.4归并排序☆☆★**1.4.1思想****1.4.2实现****1.4.3归并排序分析**1.5快速排序☆★★**
  • 【数据结构】实验一 实现顺序表各种基本运算的算法 张鱼·小丸子 数据结构实验c++数据结构
    题目：实现顺序表各种基本运算的算法要求：1、建立一个顺序表，输入n个元素并输出；2、查找线性表中的最大元素并输出；3、在线性表的第i个元素前插入一个正整数x；4、删除线性表中的第j个元素；5、将线性表中的元素按升序排列；6、将线性表中的元素就地逆序（只允许用一个暂存单元）；#include#defineSIZE1000usingnamespacestd;typedefstruct{int*a;//
  • 物联网边缘网关有哪些优势？-天拓四方 北京天拓四方科技股份有限公司 物联网其他边缘计算
    随着物联网技术的快速发展，越来越多的设备接入网络，数据交互日益频繁，对数据处理和传输的要求也越来越高。在这样的背景下，物联网边缘网关应运而生，以其低延迟、减少带宽消耗、提高数据质量和安全性等优势，为物联网应用提供了强大的支持。物联网边缘网关的应用场景广泛，几乎涵盖了所有需要实时数据处理和传输的领域。在工业场景中，边缘计算网关可以实时处理海量传感器和设备的数据，实现对运行、制造过程的全环节实时监控、
  • 职场人员学习时间管理的重大意义 时间管理v8
    时间管理是指通过事先规划和运用一定的技巧、方法与工具实现对时间的灵活以及有效运用，从而实现个人或组织的既定目标。职场人员能否在自己的事业生涯中取得成功，秘诀就在于搞好时间管理。世界上最重要的东西是"时间"，不能管理时间，便什么也不能管理。时间是世界上最短缺的资源，除非严加管理，否则就会一事无成。职场人员学习时间管理的重大意义职场中时间陷阱为什么职场人员总是觉得时间不够，经常会导致加班加点的工作？主
  • 遗落的光阴 古诗风光
    第七篇，小明的学生时代。小明和他的同桌的共听一首歌的行为已经实现了。所以每次没事就和他的同桌一起畅听音乐，这也导致了一些场面都发生，一就是她的隔壁同桌时不时的鄙夷的眼光，二是他进一步加聚了他同桌对他的态度，他的同桌除了平时的听音乐交流之外，还增加了与他的交流。其中最关键的就是，因为他的同桌没事就与他的进行生活的交流。其中最关键的就是在一个不上课的周末小明独自一人回到了宿舍进行学习。而这时他的同桌带
  • Apache Kafka的伸缩性探究：实现高性能、弹性扩展的关键 i289292951 kafkakafka
    引言ApacheKafka作为当今最流行的消息中间件之一，以其强大的伸缩性著称。在大数据处理、流处理和实时数据集成等领域，Kafka的伸缩性为其在面临急剧增长的数据流量和多样化业务需求时提供了无与伦比的扩展能力。本文将深入探讨Kafka如何通过其独特的架构设计实现高水平的伸缩性，以及在实际部署中如何优化和利用这一特性。一、Kafka伸缩性的核心设计分区（Partitioning）与水平扩展Kafk
  • Redis分布式锁—SETNX+Lua脚本实现 Sahm5k javaredis分布式lua
    使用redis实现分布式锁，就是利用redis中的setnx，如果key不存在则进行set操作返回1，key已经存在则直接返回0。优点：设置expiretime过期时间，可以避免程序宕机长期持有锁不释放。redis作为一个中间服务，所有微服务都可见，满足分布式的需求。只需redis中原生setnx命令即可构建，实现简单。性能高效，redis数据在内存中。高可用，可以部署redis集群。加锁在red
  • Django forms组件 在飞行-米龙 Djangodjangopython后端
    【一】引入【1】实现登陆验证功能（1）需求分析登陆验证需要前后端交互，采用form表单提交数据对数据进行校验用户名必须以英文大写字母开头密码必须大于三位数反馈给用户错误的信息除了反馈错误的信息还有保留原始输入内容（2）后端代码使用user_info_dict字典每次刷新存储存储前端发送的信息存储后端进行验证的信息defhome(request):#每次后刷新这个信息字典user_info_dict
  • 计算机网络知识点汇总 蓝小俊
    第1章概述P36习题3、7、14、15、17、22、24、262.“协议”与“服务”的异同点？答：（1）协议是控制两个对等实体进行通信的规则的集合。在协议的控制下，两个对等实体间的通信使得本层能够向上一层提供服务，而要实现本层协议，还需要使用下面一层提供服务。（2）协议和服务的概念的区分：1、协议的实现保证了能够向上一层提供服务。本层的服务用户只能看见服务而无法看见下面的协议。下面的协议对上面的服
  • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
  • 上班族什么副业赚钱 上班族做什么兼职赚钱 指北针聊天项目
    许多朋友都了解，目前仅靠工资收入很难储蓄，甚至难以维持生活开支，事实上，增加月收入可以通过发展副业来实现。有一些朋友可能会疑惑：如果我每天都要上班，哪里有时间来做副业呢？下面我分享10个可以在家赚钱的在线副业（建议收藏），无需投入太多时间，您可以在下班后的碎片时间进行，而且门槛很低，希望发展副业的朋友可以选择适合自己的方式来开始赚钱。有兴趣的朋友可以扫码了解我现在做的平台，没有任何费用的啦，是一个
  • java基础相关面试题详细总结 。。。。。96 java开发语言
    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
  • 你想成为怎样的人 晨星_路西法
    A：你想成为怎样的一个人？B：成为一个简单快乐，做自己想做的事。A：怎样实现呢？B：C：成为对人类有贡献的人。A：能不能具体点？C：比如，成为科学家。A：怎么实现呢？C：
  • RabbitMQ的事务机制 一只小小攻城狮 RabbitMQrabbitmq分布式
    想要保证发送者一定能把消息发送给RabbitMQ，一种是通过Confirm机制，另一种就是通过事务机制。RabbitMQ的事务机制，允许生产者将一组操作打包成一个原子事务单元，要么全部执行成功，要么全部失败。事务提供了一种确保消息完整性的方法，但需要谨慎使用，因为他们对性能有一定的影响。RabbitMQ是基于AMQP协议实现的，RabbitMQ中，事务是通过在通道（Channel）上启用的，与事务
  • Kotlin非常用关键字使用记录 Developings kotlin开发语言android
    1，typealias声明一个类型别名。样例：typealiasMyBean=ItemBeandataclassItemBean(valtitle:String,valintent:Intent)valbean=MyBean("11",Intent())实现了将ItemBean数据模型取了一个别名MyBean，后续我们可以像使用别名一样使用他们2，crossinline禁止传递给内联函数的lamb
  • Thinkphp - 详细实现网站系统登录功能，附带 Mysql 数据库设置、Web 前端展示界面、信息校验等（详细代码，即设计过程） 王佳斌 +Thinkphpmysql前端数据库
    前言登录功能，是我们几乎开发每个系统都必须的模块。登录功能设计思路，主要包括几个方面。用户输入网址展示登录页面用户输入用户名，密码等点击登录进行信息校验校验通过之后，记录用户登录信息，跳转指定页面用户校验失败，提示失败信息页面目录具体功能实现为了快速搭建可用、美观的页面，我们采用一个比较成熟的前端框架Bootstrap。下面我们到Bootstrap的官网Bootsrap官网下载bootstrap。
  • 集合框架 天子之骄 java数据结构集合框架
       集合框架 集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。   简单介绍：   Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
  • Table Driven（表驱动）方法实例 bijian1013 javaenumTable Driven表驱动
    实例一： /** * 驾驶人年龄段 * 保险行业，会对驾驶人的年龄做年龄段的区分判断 * 驾驶人年龄段：01-[18,25);02-[25,30);03-[30-35);04-[35,40);05-[40,45);06-[45,50);07-[50-55);08-[55,+∞) */ public class AgePeriodTest { //if...el
  • Jquery 总结 cuishikuan javajqueryAjaxWebjquery方法
    1.$.trim方法用于移除字符串头部和尾部多余的空格。如：$.trim('   Hello   ') // Hello2.$.contains方法返回一个布尔值，表示某个DOM元素（第二个参数）是否为另一个DOM元素（第一个参数）的下级元素。如：$.contains(document.documentElement, document.body); 3.$
  • 面向对象概念的提出 麦田的设计者 java面向对象面向过程
            面向对象中，一切都是由对象展开的，组织代码，封装数据。   在台湾面向对象被翻译为了面向物件编程，这充分说明了，这种编程强调实体。       下面就结合编程语言的发展史，聊一聊面向过程和面向对象。      c语言由贝尔实
  • linux网口绑定 被触发 linux
    刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。 一、环境描述 我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。 二、双网卡绑定步骤： 2.1 修改/etc/sysconfig/network
  • XML基础语法 肆无忌惮_ xml
    一、什么是XML？ XML全称是Extensible Markup Language，可扩展标记语言。很类似HTML。XML的目的是传输数据而非显示数据。XML的标签没有被预定义，你需要自行定义标签。XML被设计为具有自我描述性。是W3C的推荐标准。   二、为什么学习XML？ 用来解决程序间数据传输的格式问题 做配置文件 充当小型数据库   三、XML与HTM
  • 为网页添加自己喜欢的字体 知了ing 字体 秒表 css
    @font-face { font-family: miaobiao;//定义字体名字 font-style: normal; font-weight: 400; src: url('font/DS-DIGI-e.eot');//字体文件 } 使用： <label style="font-size:18px;font-famil
  • redis范围查询应用-查找IP所在城市 矮蛋蛋 redis
    原文地址： http://www.tuicool.com/articles/BrURbqV 需求 根据IP找到对应的城市 原来的解决方案 oracle表（ip_country）： 查询IP对应的城市： 1.把a.b.c.d这样格式的IP转为一个数字，例如为把210.21.224.34转为3524648994 2. select city from ip_
  • 输入两个整数， 计算百分比 alleni123 java
    public static String getPercent(int x, int total){ double result=(x*1.0)/(total*1.0); System.out.println(result); DecimalFormat df1=new DecimalFormat("0.0000%");
  • 百合——————>怎么学习计算机语言 百合不是茶 java 移动开发
        对于一个从没有接触过计算机语言的人来说，一上来就学面向对象，就算是心里上面接受的了，灵魂我觉得也应该是跟不上的，学不好是很正常的现象，计算机语言老师讲的再多，你在课堂上面跟着老师听的再多，我觉得你应该还是学不会的，最主要的原因是你根本没有想过该怎么来学习计算机编程语言，记得大一的时候金山网络公司在湖大招聘我们学校一个才来大学几天的被金山网络录取，一个刚到大学的就能够去和
  • linux下tomcat开机自启动 bijian1013 tomcat
    方法一： 修改Tomcat/bin/startup.sh 为: export JAVA_HOME=/home/java1.6.0_27 export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:. export PATH=$JAVA_HOME/bin:$PATH export CATALINA_H
  • spring aop实例 bijian1013 javaspringAOP
    1.AdviceMethods.java package com.bijian.study.spring.aop.schema; public class AdviceMethods { public void preGreeting() { System.out.println("--how are you!--"); } } 2.beans.x
  • [Gson八]GsonBuilder序列化和反序列化选项enableComplexMapKeySerialization bit1129 serialization
    enableComplexMapKeySerialization配置项的含义  Gson在序列化Map时，默认情况下，是调用Key的toString方法得到它的JSON字符串的Key，对于简单类型和字符串类型，这没有问题，但是对于复杂数据对象，如果对象没有覆写toString方法，那么默认的toString方法将得到这个对象的Hash地址。   GsonBuilder用于
  • 【Spark九十一】Spark Streaming整合Kafka一些值得关注的问题 bit1129 Stream
    包括Spark Streaming在内的实时计算数据可靠性指的是三种级别： 1. At most once，数据最多只能接受一次，有可能接收不到 2. At least once, 数据至少接受一次，有可能重复接收 3. Exactly once  数据保证被处理并且只被处理一次，   具体的多读几遍http://spark.apache.org/docs/lates
  • shell脚本批量检测端口是否被占用脚本 ronin47
    #!/bin/bash cat ports |while read line do#nc -z -w 10 $line nc -z -w 2 $line 58422>/dev/null2>&1if[ $?-eq 0]then echo $line:ok else echo $line:fail fi done 这里的ports 既可以是文件
  • java-2.设计包含min函数的栈 bylijinnan java
    具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/ import java.util.ArrayList; import java.util.List; public class MinStack { //maybe we can use origin array rathe
  • Netty源码学习-ChannelHandler bylijinnan javanetty
    一般来说，“有状态”的ChannelHandler不应该是“共享”的，“无状态”的ChannelHandler则可“共享” 例如ObjectEncoder是“共享”的, 但 ObjectDecoder 不是 因为每一次调用decode方法时，可能数据未接收完全（incomplete）， 它与上一次decode时接收到的数据“累计”起来才有可能是完整的数据，是“有状态”的 p
  • java生成随机数 cngolon java
    方法一： /** * 生成随机数 * @author [email protected] * @return */ public synchronized static String getChargeSequenceNum(String pre){ StringBuffer sequenceNum = new StringBuffer(); Date dateTime = new D
  • POI读写海量数据 ctrain 海量数据
    import java.io.FileOutputStream; import java.io.OutputStream; import org.apache.poi.xssf.streaming.SXSSFRow; import org.apache.poi.xssf.streaming.SXSSFSheet; import org.apache.poi.xssf.streaming
  • mysql 日期格式化date_format详细使用 daizj mysqldate_format日期格式转换日期格式化
    日期转换函数的详细使用说明  DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
  • 一个程序员分享8年的开发经验 dcj3sjt126com 程序员
      在中国有很多人都认为IT行为是吃青春饭的，如果过了30岁就很难有机会再发展下去!其实现实并不是这样子的，在下从事.NET及JAVA方面的开发的也有8年的时间了，在这里在下想凭借自己的亲身经历，与大家一起探讨一下。 明确入行的目的 很多人干IT这一行都冲着“收入高”这一点的，因为只要学会一点HTML, DIV+CSS，要做一个页面开发人员并不是一件难事，而且做一个页面开发人员更容
  • android欢迎界面淡入淡出效果 dcj3sjt126com android
    很多Android应用一开始都会有一个欢迎界面，淡入淡出效果也是用得非常多的，下面来实现一下。 主要代码如下： package com.myaibang.activity; import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.os.CountDown
  • linux 复习笔记之常见压缩命令 eksliang tar解压linux系统常见压缩命令linux压缩命令tar压缩
    转载请出自出处:http://eksliang.iteye.com/blog/2109693 linux中常见压缩文件的拓展名 *.gz gzip程序压缩的文件 *.bz2 bzip程序压缩的文件 *.tar tar程序打包的数据，没有经过压缩 *.tar.gz tar程序打包后，并经过gzip程序压缩 *.tar.bz2 tar程序打包后，并经过bzip程序压缩 *.zi
  • Android 应用程序发送shell命令 gqdy365 android
    项目中需要直接在APP中通过发送shell指令来控制lcd灯，其实按理说应该是方案公司在调好lcd灯驱动之后直接通过service送接口上来给APP，APP调用就可以控制了，这是正规流程，但我们项目的方案商用的mtk方案，方案公司又没人会改，只调好了驱动，让应用程序自己实现灯的控制，这不蛋疼嘛！！！！ 发就发吧！ 一、关于shell指令： 我们知道，shell指令是Linux里面带的
  • java 无损读取文本文件 hw1287789687 读取文件无损读取读取文本文件charset
    java 如何无损读取文本文件呢？ 以下是有损的 @Deprecated public static String getFullContent(File file, String charset) { BufferedReader reader = null; if (!file.exists()) { System.out.println("getFull
  • Firebase 相关文章索引 justjavac firebase
    Awesome Firebase 最近谷歌收购Firebase的新闻又将Firebase拉入了人们的视野，于是我做了这个 github 项目。 Firebase 是一个数据同步的云服务，不同于 Dropbox 的「文件」，Firebase 同步的是「数据」，服务对象是网站开发者，帮助他们开发具有「实时」（Real-Time）特性的应用。 开发者只需引用一个 API 库文件就可以使用标准 RE
  • C++学习重点 lx.asymmetric C++笔记
    1.c++面向对象的三个特性：封装性，继承性以及多态性。   2.标识符的命名规则：由字母和下划线开头，同时由字母、数字或下划线组成；不能与系统关键字重名。   3.c++语言常量包括整型常量、浮点型常量、布尔常量、字符型常量和字符串性常量。   4.运算符按其功能开以分为六类：算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符和条件运算符。 &n
  • java bean和xml相互转换 q821424508 javabeanxmlxml和bean转换java bean和xml转换
    这几天在做微信公众号 做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题， 然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ， 还是贴出来记录一下      顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。   packag
  • C 语言初级 位运算 1140566087 位运算c
    第十章 位运算   1、位运算对象只能是整形或字符型数据，在VC6.0中int型数据占4个字节   2、位运算符： 运算符 作用 ~ 按位求反 << 左移 >> 右移 & 按位与 ^ 按位异或 | 按位或 他们的优先级从高到低；   3、位运算符的运算功能： a、按位取反： ~01001101 = 101
  • 14点睛Spring4.1-脚本编程 wiselyman spring4
    14.1 Scripting脚本编程 脚本语言和java这类静态的语言的主要区别是:脚本语言无需编译,源码直接可运行; 如果我们经常需要修改的某些代码,每一次我们至少要进行编译,打包,重新部署的操作,步骤相当麻烦; 如果我们的应用不允许重启,这在现实的情况中也是很常见的; 在spring中使用脚本编程给上述的应用场景提供了解决方案,即动态加载bean; spring支持脚本
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他