java开发杂项总结

---

java开发小白杂项总结

前言：本人毕业于2021年，刚刚接触java开发，在开发过程中发现自己什么都不懂，因此写下本文作为总结自己在初入开发时遇到的问题，希望有机会看到本文的家人们，避免踩我相同的坑（有些坑自己都觉得傻，本文等于小白成长日志）。本文包括一些java写法，规范，报错问题，常见问题等杂项，希望能帮助各位和我一样刚步入java开发的小伙伴。文中有什么不对的，也希望大家不吝指点。这也是我第一次尝试写博文，一些排版等问题日后也会向大家多多学习。星光不问赶路人 时光不负有心人（本文持续更新）

一、java

1.java8新特性

（1）stream流式操作

  //使用流过滤
  public static void main(String[] args) { 
    List<String> list = new ArrayList<>();
    list.add("张无忌");
    list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");
    list.stream().filter(s->s.startsWith("张")).filter(s-> s.length() == 3).forEach(System.out::println);
    
  //流map 
  
      //1.将流中的元素映射到另一个流中，这个是在后期经常用到的，比如方法所接收的返回值是A,但是接收的却是B
    list.stream().map(item -> {
                    ProductInfoAttributes productInfoAttributes = new ProductInfoAttributes();
                    BeanUtils.copyProperties(item, productInfoAttributes);
                    productInfoAttributes.setProductId(productId);
                    productInfoAttributes.setAttributeId(IDGenerator.getId());
                    return productInfoAttributes;
                }).collect(Collectors.toList());
   
      //2.将String类型的流转换为Integer 类型
              Stream<String> stringStream = Stream.of("1", "2", "3", "4", "5", "6");
        stringStream.map(str->Integer.parseInt(str)).forEach(System.out::println);
	
      //3.方法需要返回的是List ，但是这里只有List,此时就要想到stream().map
          public  List<String> queryNamesByIds(List<Long> ids){
        
              List<Category> categories = this.categoryMapper.selectByIdList(ids);
       
    return  categories.stream().map(category -> 					            
                                    category.getName()).collect(Collectors.toList());
    }

2.static使用（与属性注入的关系）

（1）static（主函数是static修饰）只能调用调用static方法

静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。

public abstract class A {
    public static void func1(){
    }
    // public abstract static void func2();  // Illegal combination of modifiers: 'abstract' and 'static'
}

只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字，因为这两个关键字与具体对象关联。

public class A {

    private static int x;
    private int y;

    public static void func1(){
        int a = x;
        // int b = y;  // Non-static field 'y' cannot be referenced from a static context
        // int b = this.y;     // 'A.this' cannot be referenced from a static context
    }
}

（2） 静态内部类(从类的加载顺序可知【加载原则先静态后非静态，先父类再子类】)

非静态内部类依赖于外部类的实例，也就是说需要先创建外部类实例，才能用这个实例去创建非静态内部类。而静态内部类不需要。

public class OuterClass {

    class InnerClass {
    }

    static class StaticInnerClass {
    }

    public static void main(String[] args) {
        // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass();
        StaticInnerClass staticInnerClass = new StaticInnerClass();
    }
}

静态内部类不能访问外部类的非静态的变量和方法。不应该通过类实例访问静态成员，使用类名去访问

• 父类（静态变量、静态语句块）

• 子类（静态变量、静态语句块）

• 父类（实例变量、普通语句块）

• 父类（构造函数）

• 子类（实例变量、普通语句块）

• 子类（构造函数）

3.集合

（1）List中add和addAll的区别

add是添加list对象，addAll是添加list中的每一个object

4.java常用API（常看api文档）

JDK1.8源码中文说明

http://blog.fondme.cn/apidoc/jdk-1.8-google

1.集合（工具类）

 ArrayList<JSONObject> result = Lists.newArrayList();
        List<LfCategory> list = lfCommodityInfoPlMapper.findTypeList(LfType.VIDEO);
        list.addAll(lfCommodityInfoPlMapper.findTypeList(LfType.GAME));


lists.newarraylist()：

List<String> list = new ArrayList<String>(); 

new arraylist() ：

List<String> list = Lists.newArrayList();

//Lists和Maps是两个工具类, Lists.newArrayList()其实和new ArrayList()几乎一模一样, 唯一它帮你做的(其实是javac帮你做的), 就是自动推导(不是"倒")尖括号里的数据类型.

2.Arrays

//转string 
Arrays.toString

3.Collections

//判断是否为空
Collections.isEmpty

5.IO流

(1)读文件（输入流）：

BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("infilename")));

不管你从磁盘读，从网络读，或者从键盘读，读到内存，就是InputStream。

（2）写文件（输出流）:

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("outfilename")));

不管你写倒磁盘，写到网络，或者写到屏幕，都是OuputStream

6.java自带util

//CollectionUtils,集合工具类  https://blog.csdn.net/huangwenyi1010/article/details/53706297
//交并补差，是否相等，是否为空等等
CollectionUtils.isEmpty(childCategoryList);

//StringUtils,字符工具类
StringUtils.isEmpty();

二、Mysql

1)外连接查询/函数运用到相应的列

        select loi.order_no                              orderNo,
               loi.unit_price                            totalPrice,
               loi.account                               phone,
               loi.order_status                          status,
               lon.order_info                            cardInfo,
               lc.icon,
               lc.id                                     categoryId,
               //三元表达式
               IF(loi.sec_kill = 1, lcip.name, lci.name) commodityName,
               IF(loi.sec_kill = 1, lcip.type, lci.type) type,
               loi.created,
               //从该列的左边开始计算到第19位
            LEFT(aon.gmt_payment, 19)                 payTime
        from lf_order_info loi
            left join lf_commodity_info lci on loi.code = lci.code
            left join lf_commodity_info_pl lcip on loi.code = lcip.code
            left join lf_category lc on lci.category = lc.id
            left join lf_order_notify lon on loi.order_no = lon.out_id
            left join alipay_order_notify aon on loi.order_no = aon.out_trade_no
        where loi.uid = #{uid}
        GROUP BY loi.id
        order by loi.created desc
    

2)模糊查询写法

name like concat(‘%’,#{name},‘%’);

3)foreach/trim区别

//循环数组，开闭，分隔器

        #{id}

/**
trim（剪切的用法）

prefix:在trim标签内sql语句加上前缀。
suffix: 在trim标签内sql语句加上后缀。
suffixOverrides:指定去除多余的后缀内容，如：suffixOverrides=","，去除trim标签内sql语句多余的后缀","。
prefixOverrides: 指定去除多余的前缀内容
**/


        insert into lf_commodity_info
        
            code,
            name,
            value_str,
            type_code,
            member_type,
            price,

            category,

            underlined_price,
            selling_price,

            type,
            enable,
            created,
            updated,
            tax_rate,
        
        
            #{code},
            #{name},
            #{valueStr},
            #{typeCode},
            #{memberType},
            #{price},

            #{category},

            #{underlinedPrice},
            #{sellingPrice},

            #{type},
            #{enable},
            #{created},
            #{updated},
            #{taxRate},
        
    

4)Mybatis插入list集合

 insert into lf_commodity_info(
            id,
            code,
            name,
            value_str,
            type_code,
            member_type,
            category,
            price,
            underlined_price,
            selling_price,
            type,
            enable,
            tax_rate,
            created,
            updated)
            values
            <foreach collection="list" index="index" item="item" separator=",">
                (
                 #{item.id},
                 #{item.code},
                 #{item.name},
                 #{item.valueStr},
                 #{item.typeCode},
                 #{item.memberType},
                 #{item.category},
                 #{item.price},
                 #{item.underlinedPrice},
                 #{item.sellingPrice},
                 #{item.type},
                 #{item.enable},
                 #{item.taxRate},
                 #{item.created},
                 #{item.updated}
                )
            </foreach>
 //sql语句   
INSERT INTO student(name,age,sex)
VALUES("张三",12,"男"),("王三",12,"男")

5)关联查询

select icon
        from lf_category a
        right join lf_commodity_info b on a.type=b.type
        where b.category = #{category}

5.1.sql左联右联的差别

​ 左联接：已一边为主表保留其全部数据

6)嵌套查询

select icon
        from lf_category a
        where a.type = (select type
                        from lf_commodity_info b
                        where b.category = #{category})

7）distinct关键字去重

//distinct去重查询
select icon
        from lf_category a
        where a.type = (select DISTINCT type from lf_commodity_info b where b.category = #{category})
    
    
 //关联查询的去重   
    SELECT
	a.id,
	a.title,
	a.total,
	count( DISTINCT ( b.user_id ) ) AS 'read',//去重后计算该类别中的总数
	a.time,
	a.status 
FROM
	message a
	RIGHT JOIN msg_read b ON a.id = b.msg_id
	GROUP BY a.id//巧用分组，分组计算

三、Spring全家桶

1.注解

（1）Spring中异步注解@Async的使用、原理及使用时可能导致的问题

（2）

1. @requestBody（将json转成object对象，前端到后端交互时使用）

   注解@RequestBody接收的参数是来自requestBody中，即请求体。一般用于处理非 Content-Type: application/x-www-form-urlencoded编码格式的数据，比如：application/json、application/xml等类型的数据。

	  @RequestParam()：@RequestParam

注解@RequestParam接收的参数是来自HTTP请求体或请求url的QueryString中。

RequestParam可以接受简单类型的属性，也可以接受对象类型。

@RequestParam有三个配置参数：

required 表示是否必须，默认为 true，必须。
defaultValue 可设置请求参数的默认值。
value 为接收url的参数名（相当于key值）

（3）@PathVariable(接收类如aaa/{id})直接在url后的参数

（4）@Cacheable（用于缓存注解）

​ @Cacheable可以标记在一个方法上，也可以标记在一个类上。当标记在一个方法上时表示该方法是支持缓存的，当标记在一个类上时则表示该类所有的方法都是支持缓存的。对于一个支持缓存的方法，Spring会在其被调用后将其返回值缓存起来，以保证下次利用同样的参数来执行该方法时可以直接从缓存中获取结果，而不需要再次执行该方法。Spring在缓存方法的返回值时是以键值对进行缓存的，值就是方法的返回结果，至于键的话，Spring又支持两种策略，默认策略和自定义策略，这个稍后会进行说明。需要注意的是当一个支持缓存的方法在对象内部被调用时是不会触发缓存功能的。@Cacheable可以指定三个属性，value、key和condition。

（5）@Configration

​ @ConfigrationProperties(prefix=“lf”) //配置类的注解

(6)@RequestMapping请求和别的区别

  @RequestMapping(name = " 支付宝 支付返回数据", value = "/aliPay/return_url", method = {RequestMethod.POST, RequestMethod.GET})

2.OpenFeign的使用

创建应用主类Application，并通过@EnableFeignClients注解开启Spring Cloud Feign的支持功能。

@EnableEurekaClient
@SpringBootApplication
@EnableFeignClients(basePackages = { "com.kyle.client.feign.inter" })
public class Application {
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

▪️定义HelloServiceFeign，接口@FeignClient注解指定服务名来绑定服务，然后再使用Spring MVC的注解来绑定具体该服务提供的REST接口。

@FeignClient(value = "hello-service-provider")
public interface HelloServiceFeign {

    @RequestMapping(value = "/demo/getHost", method = RequestMethod.GET)
    public String getHost(String name);

    @RequestMapping(value = "/demo/postPerson", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Person postPerson(String name);
}

注意：这里服务名不区分大小写，所以使用hello-service-provider和HELLO-SERVICE-PROVIDER都是可以的。另外，在Brixton.SR5版本中，原有的serviceId属性已经被废弃，若要写属性名，可以使用name或value。

▪️接着，创建一个RestClientController来实现对Feign客户端的调用。使用@Autowired直接注入上面定义的HelloServiceFeign实例，并在postPerson函数中调用这个绑定了hello-service服务接口的客户端来向该服务发起/hello接口的调用。

@RestController
public class RestClientController {
@Autowired
private HelloServiceFeign client;

/**
 * @param name
 * @return Person
 * @Description: 测试服务提供者post接口
 * @create date 2018年5月19日上午9:44:08
 */
@RequestMapping(value = "/client/postPerson", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
public Person postPerson(String name) {
    return client.postPerson(name);
}

/**
 * @param name
 * @return String
 * @Description: 测试服务提供者get接口
 * @create date 2018年5月19日上午9:46:34
 */
@RequestMapping(value = "/client/getHost", method = RequestMethod.GET)
public String getHost(String name) {
    return client.getHost(name);

MyDev

//添加注解,实现api接口
@RestController
public class IfClient implements LfHandleApi {
    @Resource
    private LfCommodityInfoMapper lfCommodityInfoMapper;
    @Resource
    private DocLfPayService lfPayService;
    @Resource
    private LfCategoryMapper lfCategoryMapper;

    /***
     *在璐付平台进行支付
     * @param lfOrderInfo
     * @author xusj
     * 
CreateDate 2022/1/4 10:06
     */
    @Override
    public void pay(LfOrderInfo lfOrderInfo) {
        //查找商品
        LfCommodityInfo commodityInfo = lfCommodityInfoMapper.findByCode(lfOrderInfo.getCode());
        if (commodityInfo == null) {
            throw new BizException(ErrorMessages.BASIC_0001, "商品不存在");
        }
        switch (commodityInfo.getType()) {
            case LfType.VIDEO:
                lfPayService.payVideo(commodityInfo, lfOrderInfo.getAccount(), lfOrderInfo.getOrderNo());
                break;
            case LfType.GAME:
            case LfType.RECHARGE_CARD:
                lfPayService.payGame(commodityInfo, lfOrderInfo.getAccount(), lfOrderInfo.getIp(), lfOrderInfo.getOrderNo());
                break;
            case LfType.PHONE_BILL:
                lfPayService.payMobile(commodityInfo, lfOrderInfo.getAccount(), lfOrderInfo.getOrderNo());
                break;
            default:
                throw new BizException(ErrorMessages.BASIC_0001, "商品类型不存在！");
        }
    }

    @Override
    public LfCommodityInfo findByCode(String code) {
        //通过code查询
        LfCommodityInfo lfCommodityInfo = lfCommodityInfoMapper.findByCode(code);
        return lfCommodityInfo;
    }

    @Override
    public String getIcon(Long category) {
        return lfCategoryMapper.selectIcon(category);
    }

@EnableFeignClients//远程调用入口
@SpringBootApplication
@MapperScan(value = "com.xfw.welfare.docking.lf.mapper")
public class DockingApplication {

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

}

//api模块，去调用别的模块，定义api接口
@FeignClient(value = "${lf.namespace:}lf")
public interface LfHandleApi {
    /**
     * description: 调用璐付支付接口
     *
     * @param lfOrderInfo 璐付订单信息
     * @author xieran
     * @date 2021/12/29 14:18
     */
    @GetMapping("/api/welfare-lf/pay")
    void pay(@RequestBody LfOrderInfo lfOrderInfo);
    /**
     * description:获取lf商品
     *
     * @param code code
     * @return com.xfw.welfare.docking.lf.domain.LfCommodityInfo
     * @author xr
     * @date 2022/1/4 9:56 上午
     */
    @GetMapping("/api/welfare-lf/findByCode")
    LfCommodityInfo findByCode(String code);
    /**
     * description:查询产品icon
     *
     * @param category 类别id
     * @return java.lang.String
     * @author xr
     * @date 2022/1/4 4:45 下午
     */
    @GetMapping("/api/welfare-lf/getIcon")
    String getIcon(@RequestParam("category") Long category);
}

理解feign的代码架构方式

三层架构的理解，lfclient，DocLfPayservice，DocLfPayserviceimpl 区别

一、远程调用类再主服务中，实现api中api接口方法（这里写url），需要注解@RestController，类似于实现类

3.@Scheduled定时任务cron表达式

定时任务Scheduled

cron表达式详解https://help.eset.com/era_admin/65/zh-CN/cron_expression.html

@Component
public class Task
{
    @Scheduled(cron="0/5 * *  * * ? ")   //每5秒执行一次
    public void execute(){
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //设置日期格式
        System.out.println("欢迎访问 pan_junbiao的博客 " + df.format(new Date()));
    }


//启动类添加注解
@SpringBootApplication
@EnableScheduling //开启定时任务
public class ScheduledDemoApplication
{
    public static void main(String[] args)
    {
        SpringApplication.run(ScheduledDemoApplication.class, args);
    }

4.配置文件的使用

server: //端口
  port: ${APP_PORT:19970}

spring:
  application:
    name: ${order-server.namespace:}order
  cloud:
    nacos:
      username: ${NACOS_SERVER_USERNAME:nacos}
      password: ${NACOS_SERVER_PASSWORD:xfw1234}
      server-addr: ${NACOS_SERVER_ADDR:172.16.9.159:8848}
      config: //nacos中配置的前缀和yml后缀
        prefix: order
        enabled: true
        file-extension: yml
      discovery:
        enabled: true

  profiles:
    active: @profiles.active@
  main:
    allow-bean-definition-overriding: true

四、Mybatis

1、传参问题

1.MyBatis BindingException: Parameter ‘a’ not found(mapper中的参数没有在xml里被使用)

2.解决

这里需要注意的是collection必须为array，否则会报错如下：

Caused by: org.apache.ibatis.binding.BindingException: Parameter 'id' not found. Available parameters are [array]

<select id="selectList" parameterType="java.util.List" resultType="java.lang.Integer">
        SELECT COUNT(1) FROM t_user
        WHERE id IN
        <foreach collection="array" index="index" item="item"
            open="(" separator="," close=")">
            #{item}
        </foreach>
    </select>

2、result问题

MyBatis.TooManyResultsException（封装的返回值不够）

3、异常

java.sql.SQLIntegrityConstraintViolationException（违反完整性约束）:
一、其实就是违反了数据库的唯一约束条件！也就是插入数据时，具有唯一约束条件的列值重复了。
根据我图中描述信息的展示可知，我的表中"test1"这一列是具有唯一约束的，现在插入列值时数据有重复了。所以务必确认插入数据的主键或者具有唯一性约束的列不要有重复数据！！！

二、缺少主键

4.sql片段的使用

//标签和标签的使用
<sql id="selectLfCommodityInfoVo">
        select id,
               code,
               name,
               value_str,
               type_code,
               member_type,
               category,
               price,
               underlined_price,
               selling_price,
               type,
               enable,
               tax_rate,
               created,
               updated
        from lf_commodity_info
    </sql>
    <select id="findByCode" resultType="com.xfw.welfare.docking.lf.domain.LfCommodityInfo">
        <include refid="selectLfCommodityInfoVo"></include>
        where code=#{code}
    </select>

5、trim剪切标签的使用

//
 <insert id="insertLfCommodityInfo" parameterType="vip.forwe.model.lf.LfCommodityInfoModel" useGeneratedKeys="true"
            keyProperty="id">
        insert into lf_commodity_info
        <trim prefix="(" suffix=")" suffixOverrides=",">//suffixOverrides后缀覆盖
            <if test="code != null">code,</if>
            <if test="name != null">name,</if>
            <if test="valueStr != null">value_str,</if>
            <if test="typeCode != null">type_code,</if>
            <if test="memberType != null">member_type,</if>
            <if test="price != null">price,</if>

            <if test="category != null">category,</if>

            <if test="underlinedPrice != null">underlined_price,</if>
            <if test="sellingPrice != null">selling_price,</if>

            <if test="type != null">type,</if>
            <if test="enable != null">enable,</if>
            <if test="created != null">created,</if>
            <if test="updated != null">updated,</if>
            <if test="taxRate != null">tax_rate,</if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
            <if test="code != null">#{code},</if>
            <if test="name != null">#{name},</if>
            <if test="valueStr != null">#{valueStr},</if>
            <if test="typeCode != null">#{typeCode},</if>
            <if test="memberType != null">#{memberType},</if>
            <if test="price != null">#{price},</if>

            <if test="category != null">#{category},</if>

            <if test="underlinedPrice != null">#{underlinedPrice},</if>
            <if test="sellingPrice != null">#{sellingPrice},</if>

            <if test="type != null">#{type},</if>
            <if test="enable != null">#{enable},</if>
            <if test="created != null">#{created},</if>
            <if test="updated != null">#{updated},</if>
            <if test="taxRate != null">#{taxRate},</if>
        </trim>
    </insert>
    
                //separator分隔符
                
                <foreach collection="list" index="index" item="item" separator=",">
                (
                 #{item.id},
                 #{item.code},
                 #{item.name},
                 #{item.valueStr},
                 #{item.typeCode},
                 #{item.memberType},
                 #{item.category},
                 #{item.price},
                 #{item.underlinedPrice},
                 #{item.sellingPrice},
                 #{item.type},
                 #{item.enable},
                 #{item.taxRate},
                 #{item.created},
                 #{item.updated}
                )
            </foreach>

五、异常总结

1）数据截断异常

数据截断异常：（原因：导入的数据长度大于数据库长度）

Error updating database. Cause: com.mysql.cj.jdbc.exceptions.MysqlDataTruncation: Data truncation

2)BadSqlGrammarException（只要报这个异常，直接将语句放到数据库调试）

​ sql语句的问题，1.列名，2.sql语句的异常1.sql列数和参数不一样多

3）result问题

MyBatis.TooManyResultsException（封装的返回值不够）

4）异常

java.sql.SQLIntegrityConstraintViolationException（违反完整性约束）:
一、其实就是违反了数据库的唯一约束条件！也就是插入数据时，具有唯一约束条件的列值重复了。
根据我图中描述信息的展示可知，我的表中"test1"这一列是具有唯一约束的，现在插入列值时数据有重复了。所以务必确认插入数据的主键或者具有唯一性约束的列不要有重复数据！！！

二、缺少主键

5)java.lang.IllegalArgumentException: Pattern cannot be null or empty

个人经验，该传的参数没传，参数名称写错了，@requestBody/@requestParam 忘记注解

其他具体问题参考：https://blog.csdn.net/weixin_44259720/article/details/103185972

6）feign.FeignException$NotFound: [404] during [POST]

feign调用失败，当代码确定没用问题的前提下，可能时分布式架构下，多服务启动造成的问题，解决方法在调用方服务中添加被调用方服务名

六、第三方开发工具的使用

1.xshell的使用（linux常用命令行）

https://www.cnblogs.com/bowendown/p/11937159.html 下载安装地址

开发常用命令

tail -200f welfare-operation.nohup.out （）查看具体文件的后几行，查看部署环境下最后发生了什么问题

cd 进入文件

2.xxlJob分布式定时任务的使用

官方文档：https://www.xuxueli.com/xxl-job/

项目结构：

快速入门：

1.建两个分布式事务模块

2.建数据库

3.导入依赖

4.xxlJob配置类（可将配置写入nocas等），必写不然通过代码是不能注册任务的

package com.xfw.welfare.message.config;

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * xxl-job配置
 * @author xieran
 */
@Configuration
@Slf4j
public class XxlJobConfig {
    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.appname}")
    private String appname;

    @Value("${xxl.job.executor.address}")
    private String address;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;

	//执行器组件
    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        log.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }


}

5.添加并启动任务为例（其实就是调用xxljob的接口）

/***
     *请求xxl-job创建并启动任务接口
     *
     * @param xxlJobInfo 任务参数  如果 xxlJobInfo.getTriggerStatus == 1 创建的同时并启动任务,xxlJobInfo.getTriggerStatus == 0 只创建任务
     * @return {@link Integer}
     * @author xusj
     * 
CreateDate 2022/1/21 10:59
     */

//1.XxlJobInfo此参数其实理解上来就是数据库中的XxlJobInfo实体类，实体类见下方
//2.调用addAndStart见下
    public Integer addAndStart(XxlJobInfo xxlJobInfo) {
        //发送请求，到xxljobAdmin微服务的controller接口，详细结构见截图
        HttpsRequest request = new HttpsRequest(addAndStartUrl + "/jobinfo/addAndStart");
        // 任务参数
        request.setJsonBody(JSONObject.toJSONString(xxlJobInfo));
        if (request.executePostRequest()) {
            String response = request.getResponse();
            log.info("创建任务:response==={}", response);
            JSONObject jo = JSON.parseObject(response);
            if (!"200".equals(jo.getString("code"))) {
                log.error("创建启动任务失败,jobId={}", xxlJobInfo.getId());
                throw new RuntimeException(jo.getString("msg"));
//                throw new BusinessException(jo.getString("msg"));
            }
            return jo.getInteger("content");
        }
        throw new RuntimeException("创建任务失败");
//        throw new BusinessException("创建任务失败");
    }

6.实体类（对标数据库中的xxljobinfo表）

package com.xfw.welfare.message.xxljob;

import lombok.Data;

import java.util.Date;

/**
 * @author xusj
 * 
CreateDate 2022/1/21 0:30
 */
@Data
public class XxlJobInfo {
    private int id;                // 主键ID

    private int jobGroup;        // 执行器主键ID
    private String jobDesc;

    private Date addTime;
    private Date updateTime;

    private String author;        // 负责人
    private String alarmEmail;    // 报警邮件

    private String scheduleType;            // 调度类型
    private String scheduleConf;            // 调度配置，值含义取决于调度类型
    private String misfireStrategy;            // 调度过期策略

    private String executorRouteStrategy;    // 执行器路由策略
    private String executorHandler;            // 执行器，任务Handler名称
    private String executorParam;            // 执行器，任务参数
    private String executorBlockStrategy;    // 阻塞处理策略
    private int executorTimeout;            // 任务执行超时时间，单位秒
    private int executorFailRetryCount;        // 失败重试次数

    private String glueType;        // GLUE类型	#com.xxl.job.core.glue.GlueTypeEnum
    private String glueSource;        // GLUE源代码
    private String glueRemark;        // GLUE备注
    private Date glueUpdatetime;    // GLUE更新时间

    private String childJobId;        // 子任务ID，多个逗号分隔

    private int triggerStatus;        // 调度状态：0-停止，1-运行
    private long triggerLastTime;    // 上次调度时间
    private long triggerNextTime;    // 下次调度时间

    private String appName; // 执行器名称
}

7.调用上方5api

		//创建并启动任务
        XxlJobInfo xxlJobInfo = assemblyParam(msgDetRequest);
		//添加并启用
        Integer jobId = addAndStartApi.addAndStart(xxlJobInfo);


/***
     * 封装构建job任务参数方法
     *
     * @param msgDetRequest 消息请求详情
     * @return {@link XxlJobInfo}
     * @author xusj
     * 
CreateDate 2022/1/21 10:17
     */
    public XxlJobInfo assemblyParam(MsgDetRequest msgDetRequest) {
        //将时间转化为cron表达式
        String cron = DateUtil.getCron(msgDetRequest.getDate());
        //生成jobId
        Long jobId = IDGenerator.getId();
        // jobGroup必须为 ( jobGroup必须为代表的是对应执行器,如果执行器不知道是多少就默认为 0,但是必须传执行器名称appName)
        XxlJobInfo xxlJobInfo = new XxlJobInfo();
        xxlJobInfo.setId(jobId.intValue());
        xxlJobInfo.setJobGroup(0);
        xxlJobInfo.setAppName("message-executor");
        xxlJobInfo.setJobDesc("定时推送消息任务" + msgDetRequest.getTitle());
        xxlJobInfo.setAddTime(new Date());
        xxlJobInfo.setUpdateTime(new Date());
        xxlJobInfo.setAuthor("admin");
        xxlJobInfo.setScheduleType("CRON");
        xxlJobInfo.setScheduleConf(cron);
        xxlJobInfo.setMisfireStrategy("DO_NOTHING");
        xxlJobInfo.setExecutorRouteStrategy("FIRST");
        //TODO 设置jobHandler名称
        xxlJobInfo.setExecutorHandler("messageHandler");
        //TODO 任务参数 消息id
        xxlJobInfo.setExecutorParam(String.valueOf(msgDetRequest.getMsgId()));
        xxlJobInfo.setExecutorBlockStrategy("SERIAL_EXECUTION");
        xxlJobInfo.setExecutorTimeout(0);
        xxlJobInfo.setExecutorFailRetryCount(3);
        xxlJobInfo.setGlueType("BEAN");
        xxlJobInfo.setGlueRemark("GLUE代码初始化");
        xxlJobInfo.setGlueUpdatetime(new Date());
        //TODO 调度状态：0-停止，1-运行 刚添加的调度状态为0（添加定时任务默认为开启）
        xxlJobInfo.setTriggerStatus(1);
        xxlJobInfo.setTriggerLastTime(0L);
        xxlJobInfo.setTriggerNextTime(0L);
        return xxlJobInfo;
    }

3.redis使用

https://www.cnblogs.com/yechangzhong-826217795/p/11202316.html

使用安装redis 的坑

Can’t connect to redis-server

解决 运行=》services.msc=》redis启用

4.Jrebel热部署（提高开发效率）

https://www.haah.net/archives/6285.html

七、中间件的使用

1.nacos官方文档

springCloud 引入nocas官方文档 https://nacos.io/zh-cn/docs/quick-start-spring-cloud.html

1.下载，

2.导入两个依赖

3.yml书写

server:
  port: ${APP_PORT:19977}

spring:
  application:
    name: ${message.namespace:}message
  cloud:
  #重点:寻找nocas中的配置文件
    nacos:
      username: ${NACOS_SERVER_USERNAME:nacos}
      password: ${NACOS_SERVER_PASSWORD:666}
      server-addr: ${NACOS_SERVER_ADDR:172.16.9.149:666}
      config:
        prefix: message
        enabled: true
        file-extension: yml
      discovery:
        enabled: true

  profiles:
    active: dev
  main:
    allow-bean-definition-overriding: true

八、开发中Problem

1）spring中使用Junit测试

1、导入Junit依赖

​ 2、注意测试类的路径必需与非测试类路径一样

可参考：https://blog.csdn.net/weixin_39800144/article/details/79241620

注解

@RunWith(SpringRunner.class)
@SpringBootTest
public class OrderTest {
    @Resource
    private OrderPremiumServiceImpl orderPremiumService;
    @Resource
    private BaseInfoMapper baseInfoMapper;
    @Resource
    private BaseProductItemsMapper productItemsMapper;

//    @Test
//    public void testCreateOrder(){
//        CreatOrderRequest request = new CreatOrderRequest();
//
//        orderPremiumService.createOrder()
//    }

    /**
     * 测试，订单信息入库 √
     */
    @Test
    public void testSave() {
        BaseInfo baseInfo = new BaseInfo();
        baseInfo.setBaseInfoId(Long.valueOf(10));
        BaseInfoBuyerContact baseInfoBuyerContact = new BaseInfoBuyerContact();
        baseInfoBuyerContact.setBuyerId(Long.valueOf(20));
        BaseInfoSellerContact baseInfoSellerContact = new BaseInfoSellerContact();
        baseInfoSellerContact.setSellerId(Long.valueOf(30));
        BaseInfoReceInfo baseInfoReceInfo = new BaseInfoReceInfo();
        baseInfoReceInfo.setReceInfoId(Long.valueOf(50));

        BaseInfoLogistics baseInfoLogistics = new BaseInfoLogistics();
        baseInfoLogistics.setLogId(Long.valueOf(60));

        BaseInfoLogisticsItems baseInfoLogisticsItems = new BaseInfoLogisticsItems();
        baseInfoLogisticsItems.setLogItemsId(Long.valueOf(70));

        BaseProductItems baseProductItems = new BaseProductItems();
        baseProductItems.setId(Long.valueOf(80));
//        orderPremiumService.saveOrder(baseInfo, baseInfoBuyerContact, baseInfoSellerContact, baseInfoReceInfo,
//                baseInfoLogistics, baseInfoLogisticsItems, baseProductItems);
    }

2）代码规范

分new ，get，set（分点组装从参数）

总new ，get，set（将分点组装进总参数）

类中定义方法，代码冗余，地区定义

// 2. 拼接省市区镇街道，调用1688api解析地址编码，调用内部类，并调用内部类中的方法（方法定义在类中）
String districtCode = getDistrictCode(request.getDeliveryAddress().getAddressText());

/** * 地址拼接 * * @return */字符串拼接，使用stringBuilder
public String getAddressText() {    
    StringBuilder text = new StringBuilder();    	text.append(provinceText).append(cityText).append(areaText).append(townText).append(address);    
    return text.toString();}

​

3)分装json对象

//jsonObject 返回json对象（如何封装json对象）
public ArrayList<JSONObject> phoneBill() {
        ArrayList<JSONObject> result = Lists.newArrayList();
        List<LfCategory> list = lfCommodityInfoPlMapper.findTypeList(LfType.PHONE_BILL);
        list.forEach(LfCategory -> {
            JSONObject category = new JSONObject();
            category.putOpt("id", LfCategory.getId());
            category.putOpt("name", LfCategory.getName());
            category.putOpt("icon", LfCategory.getIcon());
            category.putOpt("rule", LfCategory.getRules());
            category.putOpt("specifications", lfCommodityInfoPlMapper.findCommodityListByCategoryId(LfCategory.getId()));
            int dayOfMonth = DateUtil.thisDayOfMonth();
            //每月的8-19号 有优惠 其他日期原价
            category.putOpt("discount", dayOfMonth >= Constant.PHONE_BILL_DISCOUNT_START && dayOfMonth <= Constant.PHONE_BILL_DISCOUNT_END);
            result.add(category);
        });
        return result;
    }

4)发送Http请求/获取httpRequest和httpResponse

//1,hutool 
//发送http请求
HttpResponse response = HttpRequest.post(LFPayGameRequest.URL).form(BeanUtil.beanToMap(request)).timeout(10000).execute();
//2.HttpClient发送

//怎么获得httprequest和httpresponse

public abstract class BaseHandler extends ResponseEntityExceptionHandler {
private static ServletRequestAttributes getRequestAttributes() {
    RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
    return (ServletRequestAttributes) attributes;
}

protected static HttpServletRequest getRequest() {
    return getRequestAttributes().getRequest();
}

protected static HttpServletResponse getResponse() {
    return getRequestAttributes().getResponse();
}

/**
 * 未知异常
 */
@ExceptionHandler(Throwable.class)
@ResponseBody
public Response<?> handleThrowable(Throwable ex) {
    logger.error("BaseHandler Error", ex);
    return Response.error(new BusinessException(ErrorMessages.BASIC_0001));
}
}

5）封装对象，

//lf支付请求参数，封装方法
@Data
public class LFPayGameRequest {
    //定义静态常量
    public static final String URL = "http://open.jiaofei100.com/Api/PayGame.aspx";


    private String APIID;
    private String TradeType;
    private String Account;
    private String UnitPrice;
    private String BuyNum;
    private String TotalPrice;
    private String OrderID;
    private String CreateTime;
    private String isCallBack;
    private String GoodsID;
    private String ClientIP;
    private String Sign;


    /**
     * 生成 sign
     */
    //定义类方法
    public String generateSign(String appKey) {
        String sb = "APIID=" + APIID +
                "&Account=" + Account +
                "&BuyNum=" + BuyNum +
                "&ClientIP=" + ClientIP +
                "&CreateTime=" + CreateTime +
                "&GoodsID=" + GoodsID +
                "&isCallBack=" + isCallBack +
                "&OrderID=" + OrderID +
                "&TotalPrice=" + TotalPrice +
                "&TradeType=" + TradeType +
                "&UnitPrice=" + UnitPrice +
                "&APIKEY=" + appKey;
        return MD5Util.md5Hex(sb).toUpperCase();
    }
}

6）BigDecimal类型转化千万不能强制类型转换（精度丢失，详见阿里开发手册），转化（元，分，厘）【无非就是简单的乘除操作】

//BigDecimal
//单位 厘
        BigDecimal price = infoModel.getUnderlinedPrice().multiply(new BigDecimal("1000")).setScale(0);


BigDecimal 分转元

BigDecimal feeNo = new BigDecimal(fee);//string 转 BigDecimal 分转元
feeNo = feeNo.divide(new BigDecimal(100), 2, RoundingMode.HALF_UP);//分转元

7)String 的正则表达式

fileName.matches("^.+\\.(?i)(xlsx)$")//matches方法

8)pom文件引用的坑，用于抽取API模块时，依赖引用问题

主类中应用api即可，api中不能引用主类中的依赖

9）前后端文件传输

https://blog.csdn.net/sdut406/article/details/85647982 MultipartFile与File的一些事,这两个词一般是Java中出现的吧，前者代表HTML中form data方式上传的文件，后者是文件系统的抽象，前者信息较少，只有二进制数据+文件名称

10）枚举类和属性类的区别

属性类

public class LfType {

    /**
     * 类型 ：  1.视频  2.游戏 3.话费类 4.卡密
     */
    public final static int VIDEO = 1;
    public final static int GAME = 2;
    public final static int PHONE_BILL = 3;
    public final static int RECHARGE_CARD = 4;


}

枚举类

package com.xfw.common.enums;

import lombok.Getter;

/**
 * @Classname CodeEnum
 * @Date 2021/10/19 4:19 下午
 * @Created by ys
 */
@Getter
public enum CodeResponseEnum {

    PARAMETER_ERROR(10007, "参数错误"),
    ORDER_TIMEOUT(10008, "订单超时"),
    PARAMETER_VERIFICATION_ERROR(10009, "参数校验错误"),
    AGENCY_ID_DOES_NOT_EXIST(10010, "代理商 ID 不存在"),
    NUMBER_TO_LONG(10011, "订单号长度大于 36"),
    AGENCY_STATUS_ERROR(10012, "代理商状态错误"),
    INSUFFICIENT_BALANCE(10013, "账户余额不足"),
    IP_ERROR(10014, "IP 地址验证失败"),
    PHONE_ERROR(10015, "充值号码有误"),
    NOT_SUPPORT(10016, "暂不支持该号码"),
    BAN(10017, "禁止采购该商品"),
    SUCCESS(10018, "订单提交成功"),

    FAILED(10020, "订单提交失败"),
    UNKNOWN(10021, "未知错误"),
    DUPLICATE(10022, "订单号重复"),
    NOT_SUPPORT_01(10024, "暂不支持该面值"),
    PROCESSING(10025, "订单处理中"),
    FAIL_TRANSACTION(10026, "交易失败"),
    SUCCESS_TRANSACTION(10027, "交易成功"),

    NOT_EXIST(10029, "订单不存在"),
    LIMIT(10035, "限制5分钟内同一时间和同一个金额"),
    MAINTENANCE(10036, "系统维护"),
    NOT_STARTED(10037, "活动未开始"),
    FINISH(10038, "活动已经结束"),
    ;

    private final int code;
    private final String msg;

    CodeResponseEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    /**
     * 通过code 获取 enum 对象
     */
    public static CodeResponseEnum getEnum(int code) {
        CodeResponseEnum result = null;
        for (CodeResponseEnum s : values()) {//values 表示当前枚举类
            if (s.getCode() == code) {
                result = s;
                break;
            }
        }
        return result;
    }

}

11）list.foreach的实际应用

 productCategoryList.forEach(categoryDTO -> {
     
            List<ProductCategoryResponse> childCategoryList = productCategoryFactory.getChild(allProductCategoryList,
                    categoryDTO.getId(), getAllCategoryList(), request.getQueryType());
            if(Objects.nonNull(request.getQueryType()) && request.getQueryType() == 1){
                //在商品分类界面调用，需要返回商品
                int productNum = 0;
                if(CollectionUtils.isEmpty(childCategoryList)){
                    List<Long> categoryIds = new ArrayList<>();
                    ProductCategoryRelWrapper.Selecter matcherSumProductList = new ProductCategoryRelWrapper.Selecter();
                    matcherSumProductList.categoryIdIn(categoryIds);
                    productNum = productCategoryRelMapper.selectCount(matcherSumProductList).intValue();
                }else {
                    productNum = childCategoryList.stream().mapToInt(ProductCategoryResponse::getProductNum).sum();
                }
                categoryDTO.setProductNum(productNum);
            }
            categoryDTO.setCategoryChildList(childCategoryList);
        });

12)巧用三元运算符

/**
     * 获取限购商品库存,三元运算符
     */
    public int getInventory(String purchaseLimitCode) {
        String key = getKey(purchaseLimitCode);
        Integer inventory = (Integer) redisTemplate.opsForValue().get(key);
        return inventory == null ? 0 : inventory;
    }

13）Date格式

new DateTime().toString("yyyyMMddHHmmss")//？？导入依赖，有问题
    	//java自带
   	    Date date = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = dateFormat.format(date);
        System.out.println(s);

14）excel导入导出

取excel的坑 https://blog.csdn.net/qq_35893120/article/details/80395080

导出excel模板 https://blog.51cto.com/u_15127658/4337321

15)DTO和VO的区别

http://www.tnblog.net/aojiancc2/article/details/2396

前后端交互使用request和response

VO（View Object）：封装参数

​ 视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。

DTO（Data Transfer Object）：网络传输，中间件的交互

​ 数据传输对象，泛指用于展示层与服务层之间的数据传输对象。

PO（Persistent Object）：

​ 持久化对象,就是和数据库保持一致的对象

16）开发工具安装问题，程序扫描

安装目录空格，查看报错信息，%（符号为百分号），将workspace拉到别的地方

17)配置文件

绑定异常（修改配置文件），我们使用的时Mybatis-plus，实际我们的配置为mybatis，所以配置类读取错误

mybatis-plus:

​ type-aliases-package: com.xfw.welfare.docking

​ mapper-locations: classpath* */mapper/mapping/ *.xml

18)接不到参数为空，原因

接前端参数，或者接远程调用的参数的为null时可能时因为@RequestBody注解忘记打了等注解没使用

19）为了再nacos中起不一样的服务，避免开发冲突（其中在调用方也需要配置调用方）

//不然可以会报找不到服务

20）数据库设计，时间自动增长，和插入的时间有关

阿里java

21）转化请求的时间格式

转时间格式（在类属性中）

  @ApiModelProperty(value = "操作时间，最近一次上下架的时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
    private Date operateDate;

22)在类中使用静态变量（定义常量）和方法（日常写法）

package com.xfw.welfare.docking.dto.request;

import cn.modousa.mds.common.tools.MD5Util;
import lombok.Data;

/**
 * @author xusj
 * 
CreateDate 2022/1/4 10:46
 */
@Data
public class LFPayVideoRequest {
    public static final String URL = "http://open.jiaofei100.com/Api/PayVideo.aspx";

    private String APIID;
    private String Account;
    private String ProductCode;
    private String BuyNum;
    private String OrderID;
    private String CreateTime;
    private String IsCallBack;
    private String CallBack;
    private String Sign;

    /**
     * 生成 sign
     */
    public String generateSign(String appKey) {
        String sb = "APIID=" + APIID +
                "&Account=" + Account +
                "&BuyNum=" + BuyNum +
                "&CreateTime=" + CreateTime +
                "&IsCallBack=" + IsCallBack +
                "&OrderID=" + OrderID +
                "&ProductCode=" + ProductCode +
                "&APIKEY=" + appKey;
        return MD5Util.md5Hex(sb).toUpperCase();
    }
}

23)private和public修饰属性的区别

private String a;//需要set get方法，new之后get出来

public String b;//可以new之后直接点出来

24)数据库和mq的了解

1.数据库设计 https://github.com/jly8866/archer/blob/master/src/docs/mysql_db_design_guide.md

2.了解mq的使用场景 https://www.zhihu.com/question/34243607

25)MultipartFile文件流，前后端交互

// MultipartFile转inputstream,前后端传文件流，不会传地址，传的是文件流
//例
@PostMapping("/upload")
    @ApiOperation("上传文件到oss")
    @ApiImplicitParam(name = "pathName", value = "参数，文件地址", required = true, dataType = "MultipartFile")
    public Response<String> uploadFile(@RequestParam MultipartFile pathName) throws IOException {
        String filename = pathName.getOriginalFilename();//获得流中的文件名
        InputStream inputStream = pathName.getInputStream();//将文件流转化为输入流
        String url = ossUtil.uploadFile(inputStream,filename);//调用下面的方法
        if (!StringUtils.isEmpty(url)) {
            return Response.ok(url);
        }
        log.error("文件上传到Oss失败");
        throw new BusinessException(ErrorMessages.BASIC_0001);
    }


//oss通过流上传文件
 public String uploadFile(InputStream inputStream,String fileName) throws IOException {

        //首先判断是否有welfare的存储空间
        createBucket();

        //将本地文件上传到存储空间bucket中的目录中
        //依次填写Bucket名称（例如examplebucket）、Object完整路径（例如exampledir/exampleobject.txt）和本地文件的完整路径。Object完整路径中不能包含Bucket名称。
        //TODO bucket下的目录文件夹？
        PutObjectRequest objectRequest = new PutObjectRequest(OssConfig.BUCKET_NAME, "common/" + fileName,inputStream);
        //上传文件
        PutObjectResult putObjectResult = ossClient.putObject(objectRequest);
        //判断ETag（ETag用于标识一个Object的内容）
        if (StringUtils.isEmpty(putObjectResult.getETag())) {
            log.error("上传文件失败{}");
            //关闭OssClient
            ossClient.shutdown();
            return "false";
        }
        log.info("上传文件成功{}");
        //拼接访问url
        String url = backUrl(fileName);
        //关闭OssClient
        ossClient.shutdown();
        return url;
    }



//示例，多态，没必要强行给fileinputstream，想的不全面，变通一点，在idea中查看java继承体系，ctrl+h
右键，最后一个，show继承体系
// 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件流。
//多态
InputStream inputStream = new FileInputStream("D:\\localpath\\examplefile.txt");

26）jenkens部署，发送代码时，记得发布到测试环境

27）使用mybatisplus Wrapper层的作用

除了关联查询不行，基本上都可以操作

 @Override
    public AlipayOrderInfo findByOutTradeNo(String outTradeNo) {
        AlipayOrderInfoWrapper.Selecter matcher = new AlipayOrderInfoWrapper.Selecter();
        //通过以上对象进行具体的操作
        matcher.outTradeNoEq(outTradeNo);//等于
        matcher.orderByDesc(AlipayOrderInfo.cols().id().orderNo().toList());//降序
        
        return alipayOrderInfoMapper.selectOne(matcher);//wrapper入参
    }


  @Override
    public AlipayOrderInfo findByOrderNo(String orderId) {
        AlipayOrderInfoWrapper.Selecter matcher = new AlipayOrderInfoWrapper.Selecter();
        matcher.orderNoEq(orderId);//等于不同的id，通过点出不同的东西控制
        return alipayOrderInfoMapper.selectOne(matcher);//将wrapper入参
    }

28）经常需要的时间戳（13位），获取毫秒

#### 6.时间戳
 //获得13位时间戳精确到毫秒
        long date = System.currentTimeMillis();
		//阿里开发手册强制推荐：
		//1.获取毫秒数，必须使用
        System.currentTimeMillis();
        //2，而不是
        new Date().getTime();

29）初识配置nacos

30）读取配置类中的值，配置类写法

// 配置类写法一
package com.xfw.docking.proxy.config;

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * xxl-job配置
 */
@Configuration
public class XxlJobConfig {
    private final Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @Value("${xxl.job.admin.addresses}")//通过该注解，${}，每一个点表示一层
    private String adminAddresses;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.appname}")
    private String appname;

    @Value("${xxl.job.executor.address}")
    private String address;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;


    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }


}

//yml结构

xxl:
	job:
		admin:
			addresses: "ghjhgfhj"


// 配置类写法二
@Configuration
@ConfigurationProperties(prefix = "fulu") //配置中以fulu为前缀的配置
@Data
public class FuluConfigBean {
    private  String appKey;
    private  String appSecret;
    private  String memberCode;
    private  String memberName;
    private  String gateway;
    private  String alipayAccount;
    private  String alipayAccountName;
    private  String transferAmount;
    private  String warningAmount;


}



//yml结构
fulu:
	appKey: "ghjkjhg"
	......

31）项目中的yml配置nacos中的配置

server:
  port: ${APP_PORT:19000}
  servlet:
    context-path: /
spring:
  application:
    name: ${xxl-job-admin.namespace:}xxl-job-admin
  cloud:
    nacos:
      username: ${NACOS_SERVER_USERNAME:nacos}
      password: ${NACOS_SERVER_PASSWORD:xfw1234}
      server-addr: ${NACOS_SERVER_ADDR:172.16.9.159:8848}
      config:
        prefix: xxl-job //nocos中配置的前缀
        enabled: true //启用
        file-extension: yml//nocos中配置的后缀
      discovery:
        enabled: true

  profiles:
    active: @profiles.active@
  main:
    allow-bean-definition-overriding: true

32）nacos中的配置，对标上面的配置

spring:
  datasource:
    url: jdbc:mysql://47.99.39.180:3306/welfare_dev_xxl_job?serverTimezone=CST&useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai&useInformationSchema=true
    username: root
    password: xinfengwei,2018
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    druid:
      connect-properties:
        config.decrypt: false
        config.decrypt.key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKEDoKdvmsSWILeeRuCqu4yjlaPAoKJbrJw1JNoAP20YLZmvC8kl+/bYwLpmog97lO16PELsPMy/ovq5I2fot2cCAwEAAQ==
      filter:
        config:
          enabled: true
        xfw:
          enabled: true
      max-active: 64
      initial-size: 10
      min-idle: 10
      max-wait: 6000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: select 'X'
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
### xxl-job, access token
xxl:
  job:
    accessToken: y@Ylv2fOxX07SgYm
### xxl-job, i18n (default is zh_CN, and you can choose "zh_CN", "zh_TC" and "en")
    i18n: zh_CN

## xxl-job, triggerpool max size
    triggerpool:
      fast:
        max: 200
      slow:
        max: 100
    logretentiondays: 365
    
redis:
    database: 11
    host: 47.99.39.180
    port: 6379
    password: 'xinfengwei,2018'
    timeout: 1000
    lettuce:
      pool:
        max-active: 2
        max-idle: 2
        min-idle: 1
        max-wait: -1
    servlet:
    multipart:
      max-file-size : 20MB
      max-request-size: 100MB
    cloud:
      bus:
        enabled: false

### xxl-job, log retention days
    logretentiondays: 7

environment:
  variable: DEV    

33）postman怎么传json格式

{
    'list'：[1,1],//json传集合，数组

​    "flag":1,

​    "msgId": **null**,

​    "title": "测试新建6",

​    "content": "新建内容6",

​    "imgUrl": "https://img-bss.csdn.net/1640226649214.png",

​    "proId": 1,

​    "push": 1,

​    "date": "2020-05-01 01:01:09"//json时间格式

}

34）java后端强行转时间格式

@ApiModelProperty(value = "创建时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")//此注解
	private Date created;

35)分页代码

//注意返回结果，注意传参
public PageInfo<MsgFrontPage> queryMsgPage(Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);//在这里控制就好了
        List<MsgFrontPage> messagesList = messageMapper.queryMsg();//还是全查出来
        return new PageInfo<>(messagesList);//将查出来的集合进行分页
    }

36)将字符串（string）转化为相应的数据类型的集合（List）

//
int[] ids= Arrays.stream(str.split(",")).mapToInt(s -> Integer.parseInt(s)).toArray();
//转为请求方法对应参数类型
List<Integer> collect = Arrays.stream(ids).boxed().collect(Collectors.toList());

//一个小坑，集合转为字符串之后，每个逗号后还是有空格的，所以在使用split分割的时候需要加空格
//集合转完有空格
long[] longs = Arrays.stream(substring.split(", ")).mapToLong(item -> Long.parseLong(item)).toArray();

集合转数组（阿里开发手册）

【强制】使用集合转数组的方法，必须使用集合的 toArray(T[] array)，传入的是类型完全一
致、长度为 0 的空数组。
反例：直接使用 toArray 无参方法存在问题，此方法返回值只能是 Object[]类，若强转其它类型数组将出现
ClassCastException 错误。
正例：
List<String> list = new ArrayList<>(2);
list.add("guan");
list.add("bao");
String[] array = list.toArray(new String[0]);
说明：使用 toArray 带参方法，数组空间大小的 length： 1） 等于 0，动态创建与 size 相同的数组，性能最好。
2） 大于 0 但小于 size，重新创建大小等于 size 的数组，增加 GC 负担。
3） 等于 size，在高并发情况下，数组创建完成之后，size 正在变大的情况下，负面影响与 2 相同。
4） 大于 size，空间浪费，且在 size 处插入 null 值，存在 NPE 隐患。

37）前端没有长整型，都是string

长整型都是使用string去接收，传long超过16位就会造成精度丢失

38）限制文件上传大小，添加配置文件

servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 20MB
      enabled: true

39)全局版本号的定义（父子工程pom文件的书写）

POM标签大全详解 - Youpeng - 博客园 (cnblogs.com)

//父工程例子
<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>pom</packaging>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.xfw</groupId>
    <artifactId>welfare</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>welfare</name>
    <description>描述</description>
    //版本号统一管理
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <xfw-framework.version>1.0.15</xfw-framework.version>
        <jjwt.version>0.9.1</jjwt.version>
        <springboot.version>2.3.8.RELEASE</springboot.version>
        <springcloud.version>Hoxton.SR9</springcloud.version>
        <aliyun.openservices.version>1.8.8.Final</aliyun.openservices.version>
        <spring-cloud-alibaba-dependencies.version>2.2.6.RELEASE</spring-cloud-alibaba-dependencies.version>
        <fastjson.version>1.2.66</fastjson.version>
        <lombok.version>1.18.16</lombok.version>
        <redisson.version>3.8.2</redisson.version>
        <mybatisplus.version>3.4.3.2</mybatisplus.version>
        <commons-beanutils.version>1.9.4</commons-beanutils.version>
        <welfare-version>0.0.1-SNAPSHOT</welfare-version>
        <swagger2.version>2.9.2</swagger2.version>
        <knife4j.version>2.0.9</knife4j.version>
        <swagger-models.version>1.5.22</swagger-models.version>
        <dingtalk-sdk.version>2.0.0</dingtalk-sdk.version>
    </properties>
    //父工程模块的管理子模块工程，与删除添加同步
    <modules>
        <!--网关-->
        <module>welfare-gateway</module>
        <!--商品-->
        <module>welfare-product</module>
        <!--商品对外api-->
        <module>welfare-product-api</module>
        <!--订单-->
        <module>welfare-order</module>
        <!--订单对外api-->
        <module>welfare-order-api</module>
        <!--三方璐付对接-->
        <module>welfare-lf</module>
        <!--璐付对外api，同代理proxy对接-->
        <module>welfare-lf-api</module>
        <!--通用-->
        <module>welfare-common</module>
        <!--代码生成-->
        <module>welfare-generator</module>
        <!--同步、下单、状态、代理项目，针对实体-->
        <module>welfare-docking-proxy</module>
        <!--xxl-job主项目-->
        <module>xxl-job-admin</module>
        <!--xxl-job核心包-->
        <module>xxl-job-core</module>
        <!--运营端-->
        <module>welfare-operation</module>
        <!--企业端-->
        <module>welfare-enterprise</module>
        <!--系统管理-->
        <module>welfare-system</module>
        <!--系统管理api-->
        <module>welfare-system-api</module>
        <!--消息模块-->
        <module>welfare-message</module>
        <!--消息模块api -->
        <module>welfare-message-api</module>
        <!--鉴权 -->
        <module>welfare-authentication</module>

        <module>welfare-auth</module>
        <module>welfare-auth-api</module>
        <module>welfare-push</module>
    </modules>
    //dependencyManagement：依赖管理，这是父工程需要使用的，有时内部依赖可能会爆红，可以把			    dependencyManagement删除重新down依赖即可，然后重新添加标签
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${springboot.version}</version>//引入版本号的格式
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${springcloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba-dependencies.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>com.aliyun.openservices</groupId>
                <artifactId>ons-client</artifactId>
                <version>${aliyun.openservices.version}</version>
            </dependency>
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>${jjwt.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.version}</version>
            </dependency>

            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>

            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>${redisson.version}</version>
                <optional>true</optional>
            </dependency>

            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson-spring-boot-starter</artifactId>
                <version>${redisson.version}</version>
            </dependency>

            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatisplus.version}</version>
            </dependency>

            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus</artifactId>
                <version>${mybatisplus.version}</version>
            </dependency>

            <dependency>
                <groupId>commons-beanutils</groupId>
                <artifactId>commons-beanutils</artifactId>
                <version>${commons-beanutils.version}</version>
            </dependency>

            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.21</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.23</version>
            </dependency>
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>${gson.version}</version>
            </dependency>

            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger2</artifactId>
                <version>${swagger2.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>io.swagger</groupId>
                        <artifactId>swagger-annotations</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>io.swagger</groupId>
                        <artifactId>swagger-models</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>io.swagger</groupId>
                <artifactId>swagger-models</artifactId>
                <version>${swagger-models.version}</version>
            </dependency>
            <dependency>
                <groupId>io.swagger</groupId>
                <artifactId>swagger-annotations</artifactId>
                <version>${swagger-models.version}</version>
            </dependency>
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger-ui</artifactId>
                <version>${swagger2.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>
    //依赖引入
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

//子工程例子
<?xml version="1.0" encoding="UTF-8"?>
<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>welfare</artifactId>
        <groupId>com.xfw</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>welfare-message</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    
             
             
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>archaius-core</artifactId>
                    <groupId>com.netflix.archaius</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>HdrHistogram</artifactId>
                    <groupId>org.hdrhistogram</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-io</artifactId>
                    <groupId>commons-io</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <!-- freemarker-starter -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.nacos</groupId>
            <artifactId>nacos-client</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>com.xfw</groupId>
            <artifactId>welfare-common</artifactId>
            <version>${welfare-version}</version>
            //去除依赖中的某个依赖
            <exclusions>
                <exclusion>
                    <groupId>com.xfw.framework</groupId>
                    <artifactId>xfw-framework-leopard-auth</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.xfw</groupId>
            <artifactId>welfare-authentication</artifactId>
            <version>${welfare-version}</version>
        </dependency>
        <dependency>
            <groupId>com.xfw</groupId>
            <artifactId>welfare-message-api</artifactId>
            <version>${welfare-version}</version>
        </dependency>
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>dingtalk</artifactId>
            <version>1.2.5</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.xfw.framework</groupId>
            <artifactId>xfw-framework-leopard-dingtalk-base</artifactId>
            <version>${xfw-framework.version}</version>
        </dependency>
        <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
    
             
    <repositories>
        <repository>
            <id>maven-central</id>
            <name>maven-central</name>
            <url>http://47.99.39.180:8781/repository/maven-releases/</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>
    <profiles>
        <profile>
            <!-- 本地开发环境 -->
            <id>dev</id>
            <properties>
                <profiles.active>dev</profiles.active>
            </properties>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile>
        <profile>
            <!-- 测试环境 -->
            <id>test</id>
            <properties>
                <profiles.active>test</profiles.active>
            </properties>
        </profile>
        <profile>
            <!-- 生产环境 -->
            <id>pro</id>
            <properties>
                <profiles.active>pro</profiles.active>
            </properties>
        </profile>
        <profile>
            <!-- 预发环境 -->
            <id>pre</id>
            <properties>
                <profiles.active>pre</profiles.active>
            </properties>
            <build>
                <resources>
                    <resource>
                        <directory>src/main/resources/pre</directory>
                    </resource>
                </resources>
            </build>
        </profile>
    </profiles>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>build-info</goal>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <appendAssemblyId>false</appendAssemblyId>
                    <descriptors>
                        <descriptor>src/main/assembly/assembly.xml</descriptor>
                    </descriptors>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                    <nonFilteredFileExtensions>ttf</nonFilteredFileExtensions>
                    <nonFilteredFileExtensions>pdf</nonFilteredFileExtensions>
                </configuration>
            </plugin>

            <plugin>
                <artifactId>maven-antrun-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy</id>
                        <phase>package</phase>
                        <configuration>
                            <tasks>
                                <copy todir="../target">
                                    <!-- project.build.directory表示各个模块的target目录 -->
                                    <fileset dir="${project.build.directory}">
                                        <!-- 需要复制的jar包文件名称 -->
                                        <include name="${project.artifactId}-${project.version}.jar"/>
                                    </fileset>
                                </copy>
                            </tasks>
                        </configuration>
                        <goals>
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml
                
                false
            
            
                src/main/resources
                
                    **/*.yml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>false</filtering>
                <includes>
                    <include>fonts/*
                
            
            
                src/main/resources
                true
                
                
                    test/*
                    pro/*
                    pro/*
                    dev/*
                    fonts/*
                
            
            
                src/main/resources/${profiles.active}
            
        
    

40)swagger接口文档的注意事项

1.详细，清楚

2.有状态接口文档需要枚举（如：有状态1，2，3；需要标明1，2，3的具体意思）

41）api中要求url拼接的参数形式（以钉钉发送消息模板发送data为例）

private Map<String, String> advanceBody(Date startTime, String corpId, String subjectName, Long courseId, String courseName, String coursePlanTitle,
                                        String teacherName, Integer classDuration, String role) {

    Map<String, String> body = Maps.newHashMap();
    body.put("startTime", DateUtil.dateToString(startTime, DateUtil.HH_MM));
    body.put("subjectName", subjectName);
    body.put("courseName", courseName);
    body.put("coursePlanTitle", coursePlanTitle);
    body.put("teacherName", teacherName);
    body.put("classDuration", classDuration + "");
    body.put("title", "【上课提醒】");
    // 构造dingtalk链接
    body.put("h5Url", getMsgUrl(false, role, corpId, courseId));
    body.put("pcUrl", getMsgUrl(true, role, corpId, courseId));
    return body;
}

/**
     * 拼接data
     *
     * @param msgType
     * @param title
     * @param image
     * @param content
     * @param messageUrl
     * @return
     */
    public String advanceBody(String msgType, String title, String image, String content, String messageUrl) {
        Map<String, String> body = Maps.newHashMap();
        body.put("msgType", msgType);
        body.put("title", title);
        body.put("image", image);
        body.put("content", content);
        body.put("messageUrl", messageUrl);
        return JSON.toJSONString(body);//需要string，就把map转成string，不能硬拼接需要使用map
    }

42）拼接固定参数url，java Api（StrSubstitutor）指定字符拼接，${}符号中的占位符

//${agentId}必需以${}的形式存在，占位符
    public static void main(String[] args) {
        String url="dingtalk://dingtalkclient/action/open_micro_app?corpId=${corpId}&agentId=${agentId}&miniAppId=%s&pVersion=1&packageType=1&page=%2Fpages%2Fgoods%2Fgoods%3FproductsId%3D";
        HashMap<Object, Object> map = new HashMap<>();
        map.put("corpId",122);
        map.put("agentId",1222);
        //参数为map，代替字符串中的对应位置，占位符
        StrSubstitutor strSubstitutor = new StrSubstitutor(map);
        String str = strSubstitutor.replace(url);
        System.out.println(str);
    }

43）SpringCloud Feign 传参问题及传输Date类型参数的时差（未能解决，换了方法）

44）sql语句优化（数据库优化，待学习）

1.查看sql执行过程

//sql执行过程 EXPLAIN关键字
EXPLAIN	select `id`, `corp_id`, `agent_id`, `suite_id`, `ding_user_id_added`, `create_time`, `update_time`, `auth_status`, `service_status`, `is_delete` from sys_corp_suite GROUP BY corp_id
			
			
EXPLAIN select id from sys_corp_suite where id='123456789'

2.结果

45)java8新特性对比（流的方式拿出集合中对应的指定属性,写法上的优化）

  //循环拿出userId
//所要操作的集合
List<SysCorpSuite> userList = sysCorpSuiteApi.findAddUser(item.getCorpId());

//1。lambda表达式
            List<String> useridList = userList.stream().map(user -> {
                String dingUserId = user.getDingUserIdAdded();
                return dingUserId;
            }).collect(Collectors.toList());

//2。优化写法
List<String> useridList = userList.stream().map(SysCorpSuite::getDingUserIdAdded).collect(Collectors.toList());

46）JAVA中常量使用常量类或者常量接口，还是使用枚举的区别

（具体情况具体分析，参考阿里巴巴开发手册）建议使用枚举类 https://blog.csdn.net/chenpeng19910926/article/details/76210117

47）浮点数之间的等值判断，不能使用==或equals使用方法

https://www.jianshu.com/p/dfc3ec4350e6（参考博客） 详见阿里巴巴开发手册

【强制】浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用 equals
来判断。
说明：浮点数采用“尾数+阶码”的编码方式，类似于科学计数法的“有效数字+指数”的表示方式。二进
制无法精确表示大部分的十进制小数，具体原理参考《码出高效》。
反例：
float a = 1.0F - 0.9F;
float b = 0.9F - 0.8F;
if (a == b) {
 // 预期进入此代码块，执行其它业务逻辑
 // 但事实上 a==b 的结果为 false
}
Float x = Float.valueOf(a);
Float y = Float.valueOf(b);
if (x.equals(y)) {
 // 预期进入此代码块，执行其它业务逻辑
 // 但事实上 equals 的结果为 false
}
正例：
(1) 指定一个误差范围，两个浮点数的差值在此范围之内，则认为是相等的。
float a = 1.0F - 0.9F;
float b = 0.9F - 0.8F;
float diff = 1e-6F;
if (Math.abs(a - b) < diff) {
 System.out.println("true");
}
(2) 使用 BigDecimal 来定义值，再进行浮点数的运算操作。
BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.8");
BigDecimal x = a.subtract(b);
BigDecimal y = b.subtract(c);
if (x.compareTo(y) == 0) {
 System.out.println("true");
}

48）各种数据类型之间的比较方法选用【==和equals并不是全部适用的】（阿里巴巴见开发手册）

49）遍历map集合的（4+1种）【还有一个事java8：map.forEach】

尽量使用entrySet ，java8中推荐是红map.forEach((key,value)->{}), 详情参照阿里开发手册

50）一边循环一边删除集合中的数据（必须使用迭代器，不能使用forEach）

 while (iterator.hasNext()) {
             String id = iterator.next();
             if (!sysUserProductSettingApi.getMsgUserProductSetting(Long.valueOf(id))) {
                    iterator.remove();
                }
            }

51）递归拿捏（迷宫问题，理解小测试）

package com.example.l220109.my;

import org.junit.Test;

/**
 * @author xusj
 * 
CreateDate 2022/2/10 0:41
 */
public class Rucursion {

    /**
     * 
     * 迷宫问题求解
     * 
     */
    @Test
    public void demo() {
        // 构建一个 8 行 7 列的地图
        int[][] map = initMap(8, 7);
        printMap(map);
        // 一次性没有回溯的路线
        setWay(map, 1, 1, 6, 5);
//         这个点，是有回溯的路线
//        setWay(map, 1, 1, 4, 1);
        System.out.println("路线查找完毕");
        printMap(map);
    }

    /**
     * 
     *  思路说明：
     *  1. 从 startX,startY 开始走，到 endX,endY 结束
     *  2. 当走到 endX,endY 时，表示已经找到了路线
     *  3. 约定：map 中的含义：
     *      0：表示该点没有走过
     *      1：表示围墙，不能走
     *      2：表示改点已走过，并且可以走
     *      3：表示改点已走过，但是走不通
     *
     *  4. 走迷宫，约定一个寻找路线的策略，也就是当你站在一个点的时候，你从哪一个方向开始探索？
     *     这里规定探索的方向为：下 -> 右 -> 上 -> 左，如果该点走不通，再回溯
     * 
     *
     * @param map    代表一张地图
     * @param startX 从哪一个点开始走
     * @param startY
     * @param endX   到哪一个点结束
     * @param endY
     * @return true: 表示该点可以走，false：表示改点不能走
     */
    public boolean setWay(int[][] map, int startX, int startY, int endX, int endY) {
        // 如果当结束点已经走过，表示已经到达了出口
//        System.out.println();
//        printMap(map); // 打开这个可以看到每一步的探索路径
        if (map[endX][endY] == 2) {
            return true;
        }
        // 那么开始我们的策略探索

        // 如果该点还没有走过，则可以尝试探索
        if (map[startX][startY] == 0) {
            // 先假定该点标可以通过，因为要去探索四周的点是否可以走
            map[startX][startY] = 2;
            // 下 -> 右 -> 上 -> 左
            // 根据策略：先往下走，如果可以走则返回 true
            if (setWay(map, startX + 1, startY, endX, endY)) {
                return true;
            }
            // 如果走不通，则继续往右边探索
            else if (setWay(map, startX, startY + 1, endX, endY)) {
                return true;
            }
            // 如果走不通，则继续往上边探索
            else if (setWay(map, startX - 1, startY, endX, endY)) {
                return true;
            }
            // 如果走不通，则继续往左边探索
            else if (setWay(map, startX, startY - 1, endX, endY)) {
                return true;
            }
            // 都走不通，表示改点是一个死点，四周都无法出去
            else {
                map[startX][startY] = 3;
                return false;
            }
        } else {
            // 如果不为 0，可能的情况是：1，2，3，这三种表示都表示不可以走
            return false;
        }
    }

    /**
     * 构建一个有挡板的地图
     * 
     * 数字 1：表示挡板围墙，小球不可以经过
     * 数字 0：表示是路，小球可以经过
     * 起点：可以自定义起点
     * 出口：其实也可以自定义出口，但是本题规定，出口就是右下角的 0
     * 1 1 1 1 1 1 1
     * 1 0 0 0 0 0 1
     * 1 0 0 0 0 0 1
     * 1 1 1 0 0 0 1
     * 1 0 0 0 0 0 1
     * 1 0 0 0 0 0 1
     * 1 0 0 0 0 0 1
     * 1 1 1 1 1 1 1
     * 
     *
     * @return
     */
    private int[][] initMap(int row, int cloum) {
        // 构建一个 8 行 7 列的地图
        int[][] map = new int[row][cloum];
        // 数字 1 表示挡板，构建一个有挡板的地图

        for (int i = 0; i < map[0].length; i++) {
            map[0][i] = 1;  // 顶部增加挡板
            map[map.length - 1][i] = 1;  // 底部增加挡板
        }

        for (int i = 0; i < map.length; i++) {
            map[i][0] = 1;  // 左侧增加挡板
            map[i][map[0].length - 1] = 1; // 右侧增加挡板
        }

        // 中间的其他固定挡板
        map[3][1] = 1;
        map[3][2] = 1;
        return map;
    }

    public void printMap(int[][] map) {
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[0].length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }

    /***
     * 理解小测试
     *
     * @param args
     * @author xusj
     * 
CreateDate 2022/2/10 1:10
     */
    public static void main(String[] args) {
        int i = 7;
//        test(7);
        test2(7);
    }

    public static void test(int s) {
        // 是递归
        if (s > 1) {
            test(s - 1);
        }
        System.out.println(s);


    }

    public static void test2(int j) {
        // 是递归
        if (j == 1) {
            return;
        } else {
            test2(j - 1);
            System.out.println(j);
        }
    }
}

52)专业词汇类目，spu，sku

类目：类目是一个树状结构的系统，大体上可以分成4-5级。如手机->智能手机->苹果手机类目，在这里面，手机是一级类目，苹果手机是三级类目，也是叶子类目。

SPU：苹果6（商品聚合信息的最小单位），如手机->苹果手机->苹果6，苹果6就是SPU。

SKU：土豪金 16G 苹果6 （商品的不可再分的最小单元）。

从广义上讲，类目>SPU>SKU。

53)sql模糊搜索，索引问题

索引与优化like查询

1. like %keyword 索引失效，使用全表扫描。但可以通过翻转函数+like前模糊查询+建立翻转函数索引=走翻转函数索引，不走全表扫描。
2. like keyword% 索引有效。
3. like %keyword% 索引失效，也无法使用反向索引。

54)说说count(*)、count(1)、count(列名)有什么区别？

https://juejin.cn/post/6854573219089907720

55)xml多条件模糊查询

<select id="getAllRegisterUser"
        resultType="cn.org.bjca.econtract.commonbusiness.model.polymerization.dto.UserManagerListDto">
    SELECT
    a.user_name,
    a.mobile,
    a.create_time,
    b.state
    FROM
    cb_uc_user_register a
    LEFT JOIN cb_uc_user_register_extends b ON a.id = b.user_id
    <where>
     <if test="userManagerListDto.userName != null and userManagerListDto.userName !=''">
            AND a.user_name like concat('%', #{userManagerListDto.userName},'%')
      </if>
      <if test="userManagerListDto.state != null and userManagerListDto.state != ''">
            AND b.state = #{userManagerListDto.state}
      </if>
    </where>

56)url拼接

dingtalk://dingtalkclient/action/open_micro_app?corpId=KaTeX parse error: Expected 'EOF', got '&' at position 9: {corpId}&̲agentId={agentId}&miniAppId=%s&pVersion=1&packageType=1&page=%2Fpages%2Fgoods%2Fgoods%3FproductsId%3D

dingtalk://dingtalkclient/action/open_micro_app?corpId=%s&agentId=%s&miniAppId=%s&pVersion=1&packageType=1&page=%s

57)MyBatisPlus多条件查询，组合查询

https://www.cnblogs.com/BNTang/articles/14584735.html

58)前后端交互Long和string

【强制】对于需要使用超大整数的场景，服务端一律使用 String 字符串类型返回，禁止使用 Long 类型

说明：Java 服务端如果直接返回 Long 整型数据给前端，JS 会自动转换为 Number 类型（注：此类型为双

精度浮点数，表示原理与取值范围等同于 Java 中的 Double）。Long 类型能表示的最大值是 2 的 63 次方

-1，在取值范围之内，超过 2 的 53 次方 (9007199254740992)的数值转化为 JS 的 Number 时，有些数

值会有精度损失。扩展说明，在 Long 取值范围内，任何 2 的指数次整数都是绝对不会存在精度损失的，所

以说精度损失是一个概率问题。若浮点数尾数位与指数位空间不限，则可以精确表示任何整数，但很不幸，

双精度浮点数的尾数位只有 52 位。

反例：通常在订单号或交易号大于等于 16 位，大概率会出现前后端单据不一致的情况，比如，“orderId”:

for (int i = 0; i < map.length; i++) {
for (int j = 0; j < map[0].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
}

/***
 * 理解小测试
 *
 * @param args
 * @author xusj
 * 
CreateDate 2022/2/10 1:10
 */
public static void main(String[] args) {
    int i = 7;

// test(7);
test2(7);
}

public static void test(int s) {
    // 是递归
    if (s > 1) {
        test(s - 1);
    }
    System.out.println(s);


}

public static void test2(int j) {
    // 是递归
    if (j == 1) {
        return;
    } else {
        test2(j - 1);
        System.out.println(j);
    }
}

}

#### 52)专业词汇类目，spu，sku

类目：类目是一个树状结构的系统，大体上可以分成4-5级。如手机->智能手机->苹果手机类目，在这里面，手机是一级类目，苹果手机是三级类目，也是叶子类目。

SPU：苹果6（商品聚合信息的最小单位），如手机->苹果手机->苹果6，苹果6就是SPU。

SKU：土豪金 16G 苹果6 （商品的不可再分的最小单元）。



从广义上讲，类目>SPU>SKU。



#### 53)sql模糊搜索，索引问题

索引与优化like查询

1. like %keyword    索引失效，使用全表扫描。但可以通过翻转函数+like前模糊查询+建立翻转函数索引=走翻转函数索引，不走全表扫描。
2. like keyword%    索引有效。
3. like %keyword% 索引失效，也无法使用反向索引。





#### 54)说说count(*)、count(1)、count(列名)有什么区别？

https://juejin.cn/post/6854573219089907720



#### 55)xml多条件模糊查询

```java

    SELECT
    a.user_name,
    a.mobile,
    a.create_time,
    b.state
    FROM
    cb_uc_user_register a
    LEFT JOIN cb_uc_user_register_extends b ON a.id = b.user_id
    
     
            AND a.user_name like concat('%', #{userManagerListDto.userName},'%')
      
      
            AND b.state = #{userManagerListDto.state}
      
    

 
  
56)url拼接
 
  
dingtalk://dingtalkclient/action/open_micro_app?corpId=KaTeX parse error: Expected 'EOF', got '&' at position 9: {corpId}&̲agentId={agentId}&miniAppId=%s&pVersion=1&packageType=1&page=%2Fpages%2Fgoods%2Fgoods%3FproductsId%3D
 
  
dingtalk://dingtalkclient/action/open_micro_app?corpId=%s&agentId=%s&miniAppId=%s&pVersion=1&packageType=1&page=%s
 
  
57)MyBatisPlus多条件查询，组合查询
 
  
https://www.cnblogs.com/BNTang/articles/14584735.html
 
  
58)前后端交互Long和string
 
  
【强制】对于需要使用超大整数的场景，服务端一律使用 String 字符串类型返回，禁止使用 Long 类型
 
  
说明：Java 服务端如果直接返回 Long 整型数据给前端，JS 会自动转换为 Number 类型（注：此类型为双
 
  
精度浮点数，表示原理与取值范围等同于 Java 中的 Double）。Long 类型能表示的最大值是 2 的 63 次方
 
  
-1，在取值范围之内，超过 2 的 53 次方 (9007199254740992)的数值转化为 JS 的 Number 时，有些数
 
  
值会有精度损失。扩展说明，在 Long 取值范围内，任何 2 的指数次整数都是绝对不会存在精度损失的，所
 
  
以说精度损失是一个概率问题。若浮点数尾数位与指数位空间不限，则可以精确表示任何整数，但很不幸，
 
  
双精度浮点数的尾数位只有 52 位。
 
  
反例：通常在订单号或交易号大于等于 16 位，大概率会出现前后端单据不一致的情况，比如，“orderId”:
 
  
362909601374617692，前端拿到的值却是: 362909601374617660
 
  
59)覆盖索引，利用覆盖索引进行查询，避免回表
 
  
MySQL 覆盖索引详解 - 掘金 (juejin.cn)
 
  
1.什么是回表？
 
  
2.回表怎么避免=》覆盖索引
 
  
3.使用联合索引完成
 
  
60)延迟查询（慢sql）
 
  
http://jalan.space/2020/09/01/2020/mysql-using-index/
 
  
61）数据库设计时可以考虑存json类型的字段
 
  
适用场景：存集合
 
  
62）局部变量，成员变量，静态变量的区别
 
  
https://blog.csdn.net/haovip123/article/details/43883109
 
  
63）JWT权限验证
 
  
https://www.cnblogs.com/cy0628/p/15039001.html
 
  
64）SQL对同一字段的正负数分别累计求和（求累计值）
 
  
sum( CASE WHEN detail.welfare_coin_amount > 0 THEN detail.welfare_coin_amount ELSE 0 END ) 
 
  
65）循环方法(JDK8并行流 parallelStream)
 
  
userList.parallelStream().map
 
  
66)url在线编辑器对比（https://tool.oschina.net/）
 
  
dingtalk://dingtalkclient/action/open_micro_app?corpId=%s&agentId=%s&miniAppId=5000000002072951&pVersion=1&packageType=1&page=/pages/goods-list/goods-list?id=

dingtalk://dingtalkclient/action/open_micro_app?corpId=dinged57bd8b6ba53cffbc961a6cb783455b&agentId=1447578761&miniAppId=5000000001749662&pVersion=1&packageType=1&page=%2Fpages%2Fgoods-list%2Fgoods-list%3Fid%3D332600646844
 
  
67）HttpRequest的使用（发送http请求）
 
  
      //重点：拼接方式：请求方式（get），url地址，参数，超时时间
        HttpResponse response = HttpRequest.get(LFPayMobileRequest.PAY_MOBILE_URL).form(BeanUtil.beanToMap(request)).timeout(10000).execute();
 
  
68）项目中回调的意义
 
  
流程：
 
  
1.在配置文件中配置回调参数（url）
 
  
2.写回调接口，供调用接口方进行调用（里面可写一些业务逻辑）
 
  
意义：
 
  
​ e.g.1调用支付宝时：支付宝回返回一些参数，需要调用你的接口返回，并且你可以将这些参数入库
 
  
​ e.g.2物流消息的实时更新，也是需要调用回调接口进行操作的
 
  
69）判断字符串是否是json字符串
 
  
public static boolean isJSON2(String str) {
    boolean result = false;//标记使用
    try {
        Object obj=JSON.parse(str);//fastjson方法，不是的话会抛异常
        result = true;
    } catch (Exception e) {
        result=false;
    }
    return result;
}
 
  
70）assert 断言
 
  
作用：
 
  
 
   
断言是一种调试方式，断言失败会抛出 AssertionError，只能在开发和测试阶段启用断言
 
   
对可恢复的错误不能使用断言，而应该抛出异常
 
   
JAVA中断言很少被使用，更好的方法是编写单元测试
 
  
 
  
71）异常java.lang.IllegalStateException: Method has too many Body parameters
 
  
解决：controller或者feign对外接口中有多个参数：缺少注解造成：@RequestParam 或者@requestBody
 
  
72）json的一些用法基于fastJson
 
  
将List转换为JSONArray T为实体类
 
  
List<T> list = new ArrayList<T>();
JSONArray array= JSONArray.parseArray(JSON.toJSONString(list))；

 
  
JSONArray转List RequestDTO为实体类
 
  
JSONArray array = new JSONArray();
List<RequestDTO> list = JSONObject.parseArray(array.toJSONString(), RequestDTO.class);
 
  
字符串转List T为实体类
 
  
String str = ""; 或 String str = "[{T},{T}]"
List<T> list = JSONObject.parseArray(str,T.class);
 
  
73)mybatis模糊查询
 
  
c.full_name like concat('%',#{name},'%')
 
  
74）mybatis中collection标签的使用
 
  
package com.xfw.welfare.order.response;

import com.xfw.welfare.order.request.AfterSalesRequest;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.math.BigDecimal;
import java.util.List;

/**
 * 
CreateDate 2022/2/28 10:44
 */
//返回封装类
@Data
public class OperationAfterSalesResponse {
    
    private String orderNo;
    private String applyCreateTime;
    private String status;
	//一对多定义一个类里面有集合（将数据封装到集合中）
    private List<AfterSalesGoods> afterSalesList;
	//内部类
    @Data
    @ApiModel("售后关联商品")
    public static class AfterSalesGoods {
        @ApiModelProperty(value = "主键")
        private String id;

        @ApiModelProperty(value = "订单编号")
        private String orderNo;

        @ApiModelProperty(value = "供货商订单号")
        private String providerOrderNo;

        @ApiModelProperty(value = "商品名称")
        private String goodName;

        @ApiModelProperty(value = "商品主图")
        private String goodImage;

        @ApiModelProperty(value = "规格")
        private String goodSkuName;

    }
}

 
  

DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xfw.welfare.order.mapper.XflAfterSalesMapper">

    
    //1.封装一个返回结果集（）在xml中
    <resultMap id="baseMap" type="com.xfw.welfare.order.response.OperationAfterSalesResponse">

        <result column="order_no" jdbcType="VARCHAR" property="orderNo"/>
        <result column="apply_create_time" javaType="String" property="applyCreateTime"/>
        <result column="status" javaType="String" property="status"/>
        
        // 2.collection标签的使用位置 ofType中$符号表示内部类（如果是其他的类使用具体的包路径）
        // select另一个查询方法
        // column条件：这个是第一个查询出来的结果列名和第二个查询中的列关系
        <collection property="afterSalesList"
                    ofType="com.xfw.welfare.order.response.OperationAfterSalesResponse$AfterSalesGoods"
                    select="com.xfw.welfare.order.mapper.OrderGoodsMapper.selectGoodsByOrderNo"
                    column="{orderNo = order_no}"/>
    resultMap>

  
#重点列名
    <select id="selectByCondition" resultMap="baseMap">
        SELECT a.order_no,
        a.apply_create_time,
        b.irrigation_ditch AS irrigationDitch,
        b.good_name AS goodsName,
        b.good_sku_name AS goodSkuName,
        c.full_name AS buyerName,
        c.mobile AS buyerPhone,
        a.refund_amount AS amount,
        a.`status` AS `status`,
        a.`count` AS `count`
        FROM xfl_after_sales AS a
        LEFT JOIN order_goods AS b ON a.order_no = b.order_no
        LEFT JOIN order_info AS c ON a.order_no = c.order_no
        <where>
            <if test="proName!=null and proName!=''">
                and b.good_name like concat('%',#{proName},'%')
            if>
            <if test="orderNo!=null and orderNo!=''">
                and a.order_no=#{orderNo}
            if>
            <if test="name!=null and name!=''">
                and c.full_name like concat('%',#{name},'%')
            if>
            <if test="channelId!=null and channelId!=''">
                and b.irrigation_ditch=#{channelId}
            if>
            <if test="status!=null and status!=''">
                and a.status=#{status}
            if>
            <if test="phone!=null and phone!=''">
                and c.mobile=#{phone}
            if>
        where>
    select>
mapper>

 
  
75）在设计数据库是需要预留状态（不能一直连下去，中间考虑空格便于补充状态）
 
  
订单状态 1.待付款 2待发货 3.已发货 4已完成 5.已退款 6.已关闭 10.售后中 12.下单中
 
  
----------更新2022.03.06
 
  
76）初识数据库设计注意事项
 
  
1.通过ER图理清业务实体间的关系（一对一、一对多、多对多）

2.巧用冗余字段（冗余字段：比如在影院评论表中需要查看用户信息=》需要使用userid去关联user表=》但是你需要查出userName=》可以将userName冗余在评论表中=》打破第三范式来增加查询效率【原因就是：在分布式环境中不应该为了某一个字段去远程调用别的接口，提高查询效率】）

3.巧用区分字段：比如有大小图在其中，用type去区别大小图；在省市县三级联动中可以将地名设计在一张表中，但是需要使用区分字段去判断是哪一级别（0：国家 1：省 2：市 3：县）

4.将不会轻易去变动的数据，单存放一张表，然后使用其id去放到其他的表中去关联（比如电影类型不会变动）

5.对于判断类型的业务添加字段来记录（比如定时发送和立即发送）
首先前后端在交互的时候通过一个指定的字段来判断是定时还是立即，当存入数据库的时候，也可以考虑添加该字段；同时这种操作型功能最好加上create_time和update_time
 
  
77）当Jenkins构建报错，注意查看Jenkins日志：
 
  
在Jenkens的界面的控制台输出
 
  
78）long 小数不行，转bigdecimal
 
  
long是长整型，不能有小数，可以转bigdecimal
 
  
79）修改时间格式
 
  
 String time = "2020-02-13 16:01:30";
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  Date date = null;
  try { date = sdf.parse(time); } catch (ParseException e) { e.printStackTrace(); }
 
  
80)parallelStream()优化Stream流（开内部线程去跑,效率提高）
 
  
xflAfterSalesList.parallelStream().forEach //当数据 过大时开内部线程去跑，提高效率
 
  
81)sql语句：计算一个字段中的不同状态的和
 
  
 select IFNULL(SUM(IF((op.`status` is NOT NULL), 1, 0)), 0) as `all`,
        IFNULL(SUM(IF((op.`status` = 1), 1, 0)), 0)         as waitSeller,
        IFNULL(SUM(IF((op.`status` = 2), 1, 0)), 0)         as waitBuyer,
        IFNULL(SUM(IF((op.`status` = 3), 1, 0)), 0)         as waitSellerReceive,
        IFNULL(SUM(IF((op.`status` = 6), 1, 0)), 0)         as fail
        from `xfl_after_sales` op
 
  
82）string和集合判空尽量使用stringUtil、CollectionUtil
 
  
83）类中$的意义（内部类）com.xfw.welfare.order.response.OperationAfterSalesResponse$AfterSalesGoods内部类使用$
 
  
84）MyBatis中collection标签使用：一对多
 
  
1.定义一个java类使用List集合来接对应的类
 
  
2.主要的时xml的写法(resultMap)
 
  
<select id="queryOrderDetail" resultMap="BaseMap">
        select order_no  //查询出的值对应下面的collection标签中的 column="{orderNo =order_no}"
        from `order_info`
        where del_tag = 0
        and order_no = #{orderNo}
        <if test="irrigationDitch != null and irrigationDitch != ''">
            and irrigation_ditch = #{irrigationDitch}
        if>
    select>
 
  
 <resultMap id="BaseMap" type="com.xfw.welfare.order.response.OrderResponse">
        <id column="id" jdbcType="BIGINT" property="id"/>
        <result column="order_no" jdbcType="VARCHAR" property="orderNo"/>
        <result column="order_time" jdbcType="TIMESTAMP" property="orderTime"/>
        <result column="remark" jdbcType="VARCHAR" property="remark"/>
                 // 见上面的解释
        <collection property="orderDeliveryResponse" ofType="com.xfw.welfare.order.response.OrderDeliveryResponse"
                    select="com.xfw.welfare.order.mapper.OrderDeliveryMapper.selectDeliveryByOrderNo"
                    column="{orderNo = order_no}"/>
    resultMap>
 
  
85）spring对文件上传有限制，需要在配置文件中添加
 
  
servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 20MB
      enabled: true
 
  
86）父子工程引包问题（找不到注入的类）
 
  
启动项所在的位置不对，导致扫描不到对应的位置
 
  
调用方和被调用方的启动类最好在同一个根目录下
 
  
87）sql数据截断异常
 
  
异常：com.mysql.jdbc.MysqlDataTruncation: Data truncation: Incorrect datetime value: ‘1994’ for column ‘reviewTime’ at row 1
 
  
事例：
 
  
xxljob中param不能方json等太长的，报数据截断（原因数据库的字段长度没有那么值不够大）=》解决方法1。加大字段的长度，2.思考换别的值在该字段中
 
  
88）前后端在有判断交互中添加判断字段来控制（如isOk=1/0等）
 
  
事例：需求：
 
  
定时发送和立刻发送：我刚开始判断传的时间是否为空；实际最优的方法前端添加一个字段，后端通过该字段判断
 
  
89）判断字符串中的某一个字符截断字符串
 
  
string.substring(string.lastIndexOf(".") + 1); //最后一个符号的后一位
   
string.substring(0, string.lastIndexOf(".")); // 从第一个到该符号
 
  
90）文件上传。前端多次调接口多个流的方式上传，可以以集合的方式传，返回多个
 
  
public String upload(@RequestParam("multipartFiles") List<MultipartFile> multipartFiles) {
    将流放到list中防止多张图片接口调用的过快产生的问题
 
  
91）操作性代码给前端返回boolean
 
  
92）多表操作加一定要加事务
 
  
---------更新2022.03.13
 
  
93）当上传文件时为了避免错误注意的点
 
  
1.文件中最好不要有中文
 
  
2.文件最好有唯一便是标识：如在文件中拼接上uuid等，拼接在文件名前面
 
  
94）sql查询最大的值(函数：查询最新时间也行)
 
  
select max(id)

select max（time）
 
  
95)mybatis循环插入集合
 
  
<insert id="importList" parameterType="java.util.List">
        insert into lf_commodity_info(
        id,
        code,
        name,
        value_str,
        type_code,
        member_type,
        category,
        price,
        underlined_price,
        selling_price,
        type,
        enable,
        tax_rate,
        created,
        updated,
        channel)
        values
        <foreach collection="list" index="index" item="item" separator=",">
            (
            #{item.id},
            #{item.code},
            #{item.name},
            #{item.valueStr},
            #{item.typeCode},
            #{item.memberType},
            #{item.category},
            #{item.price},
            #{item.underlinedPrice},
            #{item.sellingPrice},
            #{item.type},
            #{item.enable},
            #{item.taxRate},
            #{item.created},
            #{item.updated},
            #{item.channel}
            )
        foreach>
    insert>
 
  
96）mybatis映射返回类注意点
 
  
<resultMap id="baseMap" type="com.xfw.welfare.order.response.OperationAfterSalesResponse">

        <result column="order_no" jdbcType="VARCHAR" property="orderNo"/>
<--column:和查询中的返回值（如果as别名就使用别名）相同；jdbcType：sql字段类；property：java属性名-->
        <result column="applyCreateTime" jdbcType="VARCHAR" property="applyCreateTime"/>
        <result column="status" javaType="String" property="status"/>
<--javaType:java数据类型-->
        <result column="buyerName" javaType="String" property="buyerName"/>
        <result column="buyerPhone" javaType="String" property="buyerPhone"/>
        <collection property="afterSalesList"
                    ofType="com.xfw.welfare.order.response.OperationAfterSalesResponse$AfterSalesGoods"
                    select="com.xfw.welfare.order.mapper.OrderGoodsMapper.selectAfterSalesByOrderNo"
                    column="{orderNo = order_no}"/>
    resultMap>
 
  
97）sql分组取出最大值
 
  
select max(id),name from stu2 
group by name   
ORDER BY id //可要可不要，看业务需求
 
  
98）@JsonFormat注解统一返回类时间格式
 
  
	@ApiModelProperty(value = "申请时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")// 注解统一时间格式
    private Date applyCreateTime;
 
  
99)java指定时间
 
  
Calendar calendar=Calendar.getInstance();
        calendar.set(2015, 10, 12);  //年月日  也可以具体到时分秒如calendar.set(2015, 10, 12,11,32,52);
        Date date=calendar.getTime();//date就是你需要的时间
        System.out.println(date.toString());
 
  
100）封装请求体参数
 
  
// 某些请求API，post请求时需要在body中封装参数，参数怎么放
private Map<String, String> advanceBody(Date startTime, String corpId, String subjectName, Long courseId, String courseName, String coursePlanTitle,
String teacherName, Integer classDuration, String role) {

    Map<String, String> body = Maps.newHashMap();
    body.put("startTime", DateUtil.dateToString(startTime, DateUtil.HH_MM));
    body.put("subjectName", subjectName);
    body.put("courseName", courseName);
    body.put("coursePlanTitle", coursePlanTitle);
    body.put("teacherName", teacherName);
    body.put("classDuration", classDuration + "");
    body.put("title", "【上课提醒】");
    // 构造dingtalk链接
    body.put("h5Url", getMsgUrl(false, role, corpId, courseId));
    body.put("pcUrl", getMsgUrl(true, role, corpId, courseId));
    return body;
}
 
  
======》更新2022.03.20 01:12(更新内容，数据库设计，请求体参数封装，@jsonFormat，sql查最大，mybatis映射返回类，mybatis集合插入)
 
  
101)Controller层获取请求 头
 
  
// 获取请求头参数 注解@RequestHeader("Authorization") 
    public Response     getUserDetail(@RequestHeader("Authorization") @ApiParam(value = "校验密钥", required = true) String authorization,
                               
 
  
102）logback.xml配置
 
  

<configuration>
    
    <property name="log.path" value="D:/devprogram/idea/workspace/concurrenttest/test02/src/main/resources" />
    
    <property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />

    
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${log.pattern}pattern>
        encoder>
    appender>

    
    <appender name="file_info" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}/sys-info.logfile>
        
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            
            <fileNamePattern>${log.path}/sys-info.%d{yyyy-MM-dd}.logfileNamePattern>
            
            <maxHistory>60maxHistory>
        rollingPolicy>
        <encoder>
            <pattern>${log.pattern}pattern>
        encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            
            <level>INFOlevel>
            
            <onMatch>ACCEPTonMatch>
            
            <onMismatch>DENYonMismatch>
        filter>
    appender>

    <appender name="file_error" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}/sys-error.logfile>
        
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            
            <fileNamePattern>${log.path}/sys-error.%d{yyyy-MM-dd}.logfileNamePattern>
            
            <maxHistory>60maxHistory>
        rollingPolicy>
        <encoder>
            <pattern>${log.pattern}pattern>
        encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            
            <level>ERRORlevel>
            
            <onMatch>ACCEPTonMatch>
            
            <onMismatch>DENYonMismatch>
        filter>
    appender>

    
    <appender name="sys-user" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}/sys-user.logfile>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            
            <fileNamePattern>${log.path}/sys-user.%d{yyyy-MM-dd}.logfileNamePattern>
            
            <maxHistory>60maxHistory>
        rollingPolicy>
        <encoder>
            <pattern>${log.pattern}pattern>
        encoder>
    appender>

    
    <logger name="com.xusj" level="info" />
    
    <logger name="org.springframework" level="warn" />

    <root level="info">
        <appender-ref ref="console" />
    root>

    
    <root level="info">
        <appender-ref ref="file_info" />
        <appender-ref ref="file_error" />
    root>

    
    <logger name="sys-user" level="info">
        <appender-ref ref="sys-user"/>
    logger>
configuration>
 
  
103)application.yml与bootstrap.yml的区别
 
  
Spring Boot 默认支持 properties(.properties) 和 YAML(.yml .yaml ) 两种格式的配置文件，yml 和 properties 文件都属于配置文件，功能一样。
 
  
Spring Cloud 构建于 Spring Boot 之上，在 Spring Boot 中有两种上下文，一种是 bootstrap，另外一种是 application，下面列举这两种配置文件的区别
 
  
加载顺序
 
  
若application.yml 和bootstrap.yml 在同一目录下：bootstrap.yml 先加载 application.yml后加载
 
  
bootstrap.yml 用于应用程序上下文的引导阶段。bootstrap.yml 由父Spring ApplicationContext加载。
 
  
配置区别
 
  
bootstrap.yml 和 application.yml 都可以用来配置参数。
 
  
bootstrap.yml 用来程序引导时执行，应用于更加早期配置信息读取。可以理解成系统级别的一些参数配置，这些参数一般是不会变动的。一旦bootStrap.yml 被加载，则内容不会被覆盖。
 
  
application.yml 可以用来定义应用级别的， 应用程序特有配置信息，可以用来配置后续各个模块中需使用的公共参数等。
 
  
属性覆盖问题
 
  
启动上下文时，Spring Cloud 会创建一个 Bootstrap Context，作为 Spring 应用的 Application Context 的父上下文。
 
  
初始化的时候，Bootstrap Context 负责从外部源加载配置属性并解析配置。这两个上下文共享一个从外部获取的 Environment。Bootstrap 属性有高优先级，默认情况下，它们不会被本地配置覆盖。
 
  
也就是说如果加载的 application.yml 的内容标签与 bootstrap 的标签一致，application 也不会覆盖 bootstrap，而 application.yml 里面的内容可以动态替换。
 
  
bootstrap.yml典型的应用场景
 
  
 
   
当使用 Spring Cloud Config Server 配置中心时，这时需要在 bootstrap.yml 配置文件中指定 spring.application.name 和 spring.cloud.config.server.git.uri，添加连接到配置中心的配置属性来加载外部配置中心的配置信息
 
   
一些固定的不能被覆盖的属性
 
   
一些加密/解密的场景
 
  
 
  
104)判断时间交集
 
  
场景
 
  
两个时间段，判断是否有交集。
 
  
思想是：
 
  
找到两个时间段开始时间的最大值和结束时间的最小值。
 
  
如果开始时间的最大值小于等于结束时间的最小值则说明这两个时间段有交集。
 
  
    /***
     *
     * @param startDateOne 第一个时间段的开始时间
     * @param endDateOne 第一个时间段的结束时间
     * @param startDateTwo 第二个时间段的开始时间
     * @param endDateTwo 第二个时间段的结束时间
     * @return
     */
    public static Boolean IsInterSection(Date startDateOne,Date endDateOne,Date startDateTwo,Date endDateTwo)
    {
        Date maxStartDate = startDateOne;
        if(maxStartDate.before(startDateTwo))
        {
            maxStartDate = startDateTwo;
        }
 
        Date minEndDate = endDateOne;
        if(endDateTwo.before(minEndDate))
        {
            minEndDate = endDateTwo;
        }
        if(maxStartDate.before(minEndDate) || (maxStartDate.getTime() == minEndDate.getTime()))
        {
            return true;
        }
        else {
            return  false;
        }
    }
 
  
105)设置具体时间
 
  
Calendar calendar = Calendar.getInstance();
calendar.set(2099, Calendar.NOVEMBER, 12,10,10,10);
Date date = calendar.getTime();
 
  
106）classpath和classpath*的区别
 
  
简单的说，如果有多个文件时，classpath* 前缀再加上通配符，会搜到所有符合的文件；而classpath前缀再加上通配符则可能会在找到一个符合的之后不再查找。

所以使用classpath* 总是没错的。

mybatis:
  configuration:
    map-underscore-to-camel-case: true
  #    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations:
    - classpath:mappers/*.xml
    
    
    
mybatis-plus:
  type-aliases-package: com.xfw.welfare.docking
  mapper-locations: classpath*:**/mapper/mapping/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
 
  
107）ateway网关转发配置
 
  
gateway：
	routes:
        - id: operation
          uri: lb://${operation.namespace:}operation
          predicates:
            - Path=/api/v1/**
          filters:
            - StripPrefix=2
            - PreserveHostHeader #发送网关原始主机头
        - id: enterprise
          uri: lb://${enterprise.namespace:}enterprise
          predicates:
            - Path=/api/v1/**
          filters:
            - StripPrefix=2
            - PreserveHostHeader #发送网关原始主机头
 
  
108)zuul区别
 
  
zuul：
	routes：
		service： /a/**   服务名：地址
 
  
109)get请求传时间，配置时间格式
 
  
 @RequestParam(value = "endTime", required = false) @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss") Date endTime
 
  
110)springboot中使用junit测试
 
  
// 1、导入依赖
<!--junit测试集成spring-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
// 2、测试包（与项目包同名，不然会有错）
    
// 3、建工程（注意添加的注解）
    package com.xusj.test;

import com.xusj.test.entity.Msg;
import com.xusj.test.service.MsgService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author xusj
 * 
CreateDate 2022/3/24 9:58
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class test {
    @Resource
    private MsgService msgService;
    @Test
    public void test01(){
        List<Msg> msgs = msgService.selectAll();
        for (Msg msg : msgs) {
            System.out.println(msg);
        }
    }
}

 
  
111)SSH整合时出现java.lang.IllegalStateException: @Resource annotation requires a single-arg method: …的错误解决
 
  
有一个地方多了注解@Resource，或者写反了
 
  
112)注意int的长度，当生成的id时，int和long之间的精度问题
 
  
//string转int，有时候可能会太长，可以先使用long转，在用math方法弄
xxlJobInfo.setId(Math.toIntExact(Long.valueOf(jobId)))
 
  
===》2022.03.28（更新：logback，精度，注入异常、又见junit、配置文件区别、网关的使用）
 
  
113）当代码出现问题时一定要有微观到宏观
 
  
比如debug到当前行数出错，那就先看这一行的原因，在已宏观的方法去看问题
 
  
114）@JsonFormat和@DataTimeFormat的区别
 
  
注解@JsonFormat主要是后台到前台的时间格式的转换
 
  
注解@DataTimeFormat主要是前后到后台的时间格式的转换
 
  
@DateTimeFormat(pattern = "yyyy-MM-dd")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date symendtime;
 
  
115）所有的查询都要进行判空校验
 
  
集合判空使用collectionUtils
 
  
字符串判空使用StringUtils
 
  
116）包装类的判断是否，相等使用equals
 
  
117）尽量不要在循环中调用数据库连接去查询修改等，原因数据库连接有限，资源宝贵，解决方法：
 
  
使用mybatis中批量修改，和map查询调用一次数据库连接即可
 
  
118)mybatis一对多和多对多的写法和理解
 
  
1】编写返回类
 
  
@Data
public class MovieVo extends Movie {
	// 一对一
    private String movieAreaStr;
	// 一对多
    private List<MovieType> movieTypeList;
	//一对多
    private List<MovieImage> movieImageList;
}
 
  
2】编写mapper.xml 要点：封装resultMap
 
  

    <resultMap type="com.xusj.cinema.vo.MovieVo" id="MovieVoResult">
        <result property="movieId"    column="movie_id"    />
        <result property="movieName"    column="movie_name"    />
        <result property="movieReleaseTime"    column="movie_release_time"    />
        <result property="movieArea"    column="movie_area"    />
        <result property="movieInfo"    column="movie_info"    />
        <result property="movieVersion"    column="movie_version"    />
        <result property="movieImg"    column="movie_img"    />
        <result property="movieEname"    column="movie_ename"    />
        <result property="movieScore"    column="movie_score"    />
        <result property="movieStatus"    column="movie_status"    />
        <result property="movieCount"    column="movie_count"    />
        <result property="movieBoxOffice"    column="movie_box_office"    />
        <result property="movieTime"    column="movie_time"    />
        <result property="movieWantCount"    column="movie_want_count"    />
        <result property="movieReleaseYear"    column="movie_release_year"    />
        <result property="commentUserCount"    column="comment_user_count"    />
        <association property="movieAreaStr" column="movie_area" select="com.xusj.cinema.mapper.MovieAreaMapper.selectMovieAreaByAreaId">association>
        <collection property="movieTypeList" ofType="com.xusj.cinema.domain.MovieType" column="movie_id"
                    select="com.xusj.cinema.mapper.MovieTypeMapper.selectMovieTypeByMovieId">collection>
    resultMap>


<select id="queryAllMovies" resultMap="MovieVoResult">
        <include refid="selectMovieVo"/>
select>
 
  
图解一对一和一对多写法（在绿标处column处不需要列名相同，只是为了拿到查询结果中该列的值去关联查询）
 
 
  
总结：写法重点在于书写resultMap
 
  
===》2022.04.10（更新：开发注意事项，mybatis一对多和多对多查询总结）
 
  
119）简单的覆写的方法
 
  
创建一个包名和类名都相同的类
 
  
我遇到的情况，sdk中封装问题导致这个类需要覆写。
 
  
===》2022.4.17
 
  
Linux命令行，定位日志
 cat 服务名|grep 需要定位的日志内容
 
  
【推荐】在所有的查询语句中都加上排序 order by
 
  
场景：我在处理大数据量的时候，对每一页数据分配一个线程区处理，导致数据一直丢失或者对不上，经过排查发现，没加排序，导致每页查出来的数据不是固定的，所以有的数据丢失了。加上排序即可。
 
  
在业务中分页查询其实也是一样的道理，一直会变数据，这里也要加上排序。
 
  
小白等于入门中能完成crud该篇，博文停更；接下来持续输出
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(日常开发,java,开发语言,后端)
        

            

                

                    
Long类型前后端数据不一致
                        igotyback
前端
                        
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
                    
                    
LocalDateTime 转 String
                        igotyback
java开发语言
                        
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
                    
                    
Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
                    
                    
使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
                    
                    
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
                    
                    
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
                    
                    
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
                    
                    
HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
                    
                    
node.js学习
                        小猿L
node.jsnode.js学习vim
                        
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
                    
                    
Low Power概念介绍-Voltage Area
                        飞奔的大虎

                        
随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
                    
                    
Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
                    
                    
简单了解 JVM
                        记得开心一点啊
jvm
                        
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
                    
                    
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
                    
                    
Java企业面试题3
                        马龙强_
java
                        
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
                    
                    
JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
                    
                    
Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
                    
                    
白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
                    
                    
python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
                    
                    
ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
                    
                    
Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
                    
                    
Java：爬虫框架
                        dingcho
Javajava爬虫
                        
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
                    
                    
python怎么将png转为tif_png转tif
                        weixin_39977276

                        
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
                    
                    
springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
                    
                    
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
                    
                    
uniapp map组件自定义markers标记点
                        以对_
uni-app学习记录uni-appjavascript前端
                        
需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
                    
                    
JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
                    
                    
笋丁网页自动回复机器人V3.0.0免授权版源码
                        希希分享
软希网58soho_cn源码资源笋丁网页自动回复机器人
                        
笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
                    
                    
WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
                    
                    
博客网站制作教程
                        2401_85194651
javamaven
                        
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
                    
                    
00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
                    
                                
[黑洞与暗粒子]没有光的世界
                                    comsci

                                    
     无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算 
 
     但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界.... 
 
     那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的 
 
&nbs
                                
                                
jQuery Lazy Load 图片延迟加载
                                    aijuans
jquery
                                    
基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。 
对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。 
 
 版本： 
 

  jQuery v1.4.4+ 
 

  jQuery Lazy Load v1.7.2 
 
 
 注意事项： 
 
 
 需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
                                
                                
使用Jodd的优点
                                    Kai_Ge
jodd
                                    
1.  简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。 
2.  简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。 
3.  对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。 
  
使用方法简介
                                
                                
jpa Query转hibernate Query
                                    120153216
Hibernate
                                    
public List<Map> getMapList(String hql,
			Map map) {
		org.hibernate.Query jpaQuery = entityManager.createQuery(hql);
		if (null != map) {
			for (String parameter : map.keySet()) {
				jp
                                
                                
Django_Python3添加MySQL/MariaDB支持
                                    2002wmj
mariaDB
                                    
现状 
首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案 
首先据MySQL文档[3]说，自从MySQL
                                
                                
在SQLSERVER中查找消耗IO最多的SQL
                                    357029540
SQL Server
                                    
返回做IO数目最多的50条语句以及它们的执行计划。 
select top 50   
 
(total_logical_reads/execution_count) as avg_logical_reads,  
 
(total_logical_writes/execution_count) as avg_logical_writes,  
 
(tot
                                
                                
spring UnChecked 异常 官方定义！
                                    7454103
spring
                                    
  如果你接触过spring的 事物管理！那么你必须明白 spring的 非捕获异常！ 即 unchecked 异常！ 因为 spring 默认这类异常事物自动回滚！！ 
 
 
 
 
public static boolean isCheckedException(Throwable ex)
    {
   return !(ex instanceof RuntimeExcep
                                
                                
mongoDB 入门指南、示例
                                    adminjun
javamongodb操作
                                    
一、准备工作 
1、 下载mongoDB 
下载地址：http://www.mongodb.org/downloads 
选择合适你的版本 
相关文档：http://www.mongodb.org/display/DOCS/Tutorial 
2、 安装mongoDB 
A、 不解压模式： 
将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
                                
                                
CUDA 5 Release Candidate Now Available
                                    aijuans
CUDA
                                    
The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
                                
                                
Essential Studio for WinRT网格控件测评
                                    Axiba
JavaScripthtml5
                                    
Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。 
 
 
网格控件功能 
1、
                                
                                
java 获取windows系统安装的证书或证书链
                                    bewithme
windows
                                    
  
    有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库  。 
有关证书链的解释可以查看此处 。 
  
public static void main(String[] args) {
		SunMSCAPI providerMSCAPI = new SunMSCAPI();
		S
                                
                                
NoSQL数据库之Redis数据库管理(set类型和zset类型)
                                    bijian1013
redis数据库NoSQL
                                    
4.sets类型 
        Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。 
        sadd：向名称为key的set中添加元
                                
                                
异常捕获何时用Exception，何时用Throwable
                                    bingyingao

                                    
用Exception的情况 
 try { 
       //可能发生空指针、数组溢出等异常 
        } catch (Exception e) { 
         
                                
                                
【Kafka四】Kakfa伪分布式安装
                                    bit1129
kafka
                                    
在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证   1. 安装步骤 
  
Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
                                
                                
Project Euler
                                    bookjovi
haskell
                                    
Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。 
    看看problem 1吧： 
 Add all the natural num
                                
                                
Java-Collections Framework学习与总结-ArrayDeque
                                    BrokenDreams
Collections
                                    
        表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。 
        这篇要看一下java.util.ArrayDeque。从命名上看
                                
                                
读《研磨设计模式》-代码笔记-装饰模式-Decorator
                                    bylijinnan
java设计模式
                                    
声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.Fi
                                
                                
Maven学习(一)
                                    chenyu19891124
Maven私服
                                    
    学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
                                
                                
[原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充
                                    comsci
算法工作PHP搜索引擎嵌入式
                                    
本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点 
 
 节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法) 
 
 需要解决的问题：已知分支
                                
                                
Linux中用shell获取昨天、明天或多天前的日期
                                    daizj
linuxshell上几年昨天获取上几个月
                                    
在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年 
 
 
# 获取昨天 
date -d 'yesterday'  # 或 date -d 'last day' 
# 获取明天 
date -d 'tomorrow'   # 或 date -d 'next day' 
# 获取上个月 
date -d 'last month' 
# 
                                
                                
我所理解的云计算
                                    dongwei_6688
云计算
                                    
      在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说： 
 
        Cloud computing is a phrase used to describe a variety of computing co
                                
                                
YII CMenu配置
                                    dcj3sjt126com
yii
                                    
Adding id and class names to CMenu 
We use the id and htmlOptions to accomplish this. Watch.   
//in your view
$this->widget('zii.widgets.CMenu', array(
	'id'=>'myMenu',
	'items'=>$this-&g
                                
                                
设计模式之静态代理与动态代理
                                    come_for_dream
设计模式
                                    
静态代理与动态代理 
        代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
                                
                                
【转】理解Javascript 系列
                                    gcc2ge
JavaScript
                                    
理解Javascript_13_执行模型详解 
 
  摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
                                
                                
Subsets II
                                    hcx2013
set
                                    
Given a collection of integers that might contain duplicates, nums, return all possible subsets. 
Note: 
 
 Elements in a subset must be in non-descending order. 
 The solution set must not conta
                                
                                
Spring4.1新特性——Spring缓存框架增强
                                    jinnianshilongnian
spring4
                                    
目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
                                
                                
shell嵌套expect执行命令
                                    liyonghui160com

                                    
  
  
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧. 
  系统:centos 5.x 
  
1.先安装expect 
yum -y install expect 
  
2.脚本内容: 
cat auto_svn.sh 
  
#!/bin/bash

                                
                                
Linux实用命令整理
                                    pda158
linux
                                    
0. 基本命令   　　linux 基本命令整理   　 
　1. 压缩 解压   　　tar -zcvf a.tar.gz a   #把a压缩成a.tar.gz   　　tar -zxvf a.tar.gz     #把a.tar.gz解压成a   　 
　2. vim小结   　　2.1 vim替换   　　:m,ns/word_1/word_2/gc  
                                
                                
独立开发人员通向成功的29个小贴士
                                    shoothao
独立开发
                                    
  
 概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。  
   
 
 明白你从事独立开发的原因和目的。 
 保持坚持制定计划的好习惯。 
 万事开头难，第一份订单是关键。 
 培养多元化业务技能。 
 提供卓越的服务和品质。 
 谨小慎微。 
 营销是必备技能。 
 学会组织，有条理的工作才是最有效率的。 
 “独立
                                
                                
JAVA中堆栈和内存分配原理
                                    uule
java
                                    
1、栈、堆  
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.