Lombok使用

发表于 2019-01-27

Lombok的使用

什么是lombok？

连官网都懒得废话，只给出了一句广告词：给你的java加点料(spice up your java)。

我们自己来总结一下：

lombok是一个ide插件，它可以让我们写更少的代码，而编译出更多的字节码。

我们可以让我们编译出一个复杂的.class文件，而我们的.java文件很干净清爽。

lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过通用对应的注解，在编译源码的时候生成对应的方法。

阅读全文 »

Java设计笔记

发表于 2018-11-13

一、Controller层

定义每个模块的restful接口

1 2	@RestController @RequestMapping(value = "/user", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)

只负责控制逻辑与返回响应数据

1	return new ResponseEntity<>(HttpStatus.OK.toString(), HttpStatus.OK);

每个controller添加日志

1	Logger logger = LoggerFactory.getLogger(this.getClass());

将request请求传递给业务层(service)

1	String name = userService.getUserName(Id, request)

添加一个Template 和一个响应实体ResponseEntity<>将返回的数据放入模板中，然后将模板封装到响应实体之中，最后将相应实体发送给前端
1
2
UserTemplate user = userService.getUserById(Id, request);
ResponseEntity<>(user, HttpStatus.OK)
针对不同的请求添加不同的注解

1	@GetMapping("/xxx") @PosstMapping("/xxx") @PutMapping("/xxx")

使用@PathVariable(value = “id”) 支持Restful
使用@RequestParam接受Request中的数据
使用数据字典，将常量统一保存到指定的类中进行管理。

二、Service层

分页

@Override
// SearchVo 封装了查询条件
public List<User> getList(SearchVo searchVo, PageInfo pageInfo) {
    List<User> userList = new ArrayList<>();
    // 获取总行数
    Integer totalSize = userMapper.getUserCount(searchVo);
    // 增强鲁棒性
    if (totalSize == null || totalSize == 0) {
        pageInfo.setTotalSize(0);
        pageInfo.setPageCount(0);
    } else {
        pageInfo.setTotalSize(totalSize);
        pageInfo.setPageCount((int) Math.ceil((totalSize * 1.0) / 		      	  ----(pageInfo.getPageSize() * 1.0)));        
        Integer offset = (pageInfo.getPageNo() - 1) * pageInfo.getPageSize();
        searchVo.setOffset(offset);
        searchVo.setPageSize(pageInfo.getPageSize());
        // 查询数据
        userList = userMapper.searchUser(searchVo);
    }
    return userList;
}

1	StringUtils.isEmpty() //判断是否为空

事务处理

1	@Transactional(rollbackFor = {Throwable.class, Exception.class})

如果出现异常向上抛出
数据的封装
业务的处理

三、 Mapper层

定制sql


@SelectProvider(type = BookSQLProvider.class, method = "searchBook")
Integer getDsDashboardCount(SearchVo searchBean);
public class BookSQLProvider {
    public String searchBook(SearchVo searchBean) {
        StringBuffer sql = new StringBuffer(new SQL(){{
            SELECT("count(1)");
            FROM("db_book b, db_person p");
            WHERE("b.id = p.id");
            if (!StringUtils.isEmpty(searchBean.getDashboardName())){
                WHERE("title like '"+searchBean.getDashboardName()+"%'");
            }
            if (!StringUtils.isEmpty(searchBean.getCreator())) {
                WHERE("creator = #{creator}");
            }
        }}.toString());
        return sql.toString();
    }

CRUD

1
2
3

@Insert("INSERT INTO dp_report_dashboards (title) VALUES (#{title})") // 关键字大写
@Options(useGeneratedKeys=true, keyProperty="id") // 主键自增
void createDashboard(MetaDashboard dashboard);

注解@Results

@Results({
	@Result(property = "id", column = "id", javaType = Long.class, jdbcType = JdbcType.BIGINT),
    @Result(property = "book_price", column = "db_id", javaType = Long.class, jdbcType = JdbcType.BIGINT),
    @Result(property = "image", column = "iamge", javaType = Image.class,many = @many(select = "com.mx.mappers.ImageMapper.getImageById")),
@Result(
    property = "company_id", column = "company_id", javaType = List.class,many = 		@Many(select ="com.mx.mappers.CompanyMapper.getInfoById"))
})

Trie

发表于 2018-10-05

public class Trie {
    private class Node {
        // 判断是否是一个单词，我们不能只依靠叶子节点来判断是否结束
        boolean isWord;
        // 边与节点的映射
        Map<Character, Node> next;
        public Node(boolean isWord) {
            this.isWord = isWord;
            next = new TreeMap<>();
        }

        public Node() {
            this(false);
        }
    }
    private Node root;
    private int size;

    public Trie() {
        root = new Node();
        size = 0;
    }

    // 获取单词数量
    public int getSize() {
        return size;
    }

    // 向Trie中添加新的单词word
    public void add(String word) {
        Node cur = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            if (cur.next.get(c) == null) {
                cur.next.put(c, new Node());
            }
            cur = cur.next.get(c);
        }

        if (!cur.isWord) {
            cur.isWord = true;
            size++;
        }
    }

    public boolean constains(String word) {
        Node cur = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            if (cur.next.get(c) == null) {
                return false;
            }
            cur = cur.next.get(c);
        }
        // 返回这个单词是否包含
        return cur.isWord;
    }
    // 查询是否存在Trie中有单词以prefix为前缀
    public boolean isPrefix(String prefix) {
        Node cur = root;
        for (int i = 0; i < prefix.length(); i++) {
            char c = prefix.charAt(i);
            if (cur.next.get(c) == null) {
                return false;
            }
            cur = cur.next.get(c);
        }
        return true;
    } 
}

Java注解

发表于 2018-09-27

java注解的使用

阅读全文 »

红黑树

发表于 2018-09-24

特点

每个节点或者是红色的或者是黑色的
根结点都是黑色的
每一个叶子节点（最后的空节点）是黑色的
如果一个节点是红色的，那么他的孩子节点都是黑色的
从任意一个节点到叶子节点，经过的黑色节点是一样的

阅读全文 »

线段树

发表于 2018-09-20

阅读全文 »

GC

发表于 2018-09-17

GC的相关介绍

阅读全文 »

AVL树

发表于 2018-08-21

class AVLTree<K extends Comparable<K>, V> {
    
    private class Node {
        public K key;
        public V value;
        public Node left, right;
        public int height;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            left = null;
            right = null;
            height = 1;
        }
    }

    private Node root;
    private int size;

    public AVLTree() {
        root = null;
        size = 0;
    }

    public int getSize() {
        return size;
    }

    // 获得节点的高度
    private int getHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean contains(K key) {
        return getNode(root, key) != null;
    }

    // 添加元素
    public void add(K key, V value) {
        root = add(root, key, value);
    }

    // 向以node为根的二分搜索树种插入元素E
    private Node add(Node node, K key, V value) {
        // 当我们递归到null的时候就一定要创建一个节点
        if (node == null) {
            size++;
            return new Node(key, value);
        }

        if (key.compareTo(node.key) < 0) {
            node.left = add(node.left, key, value);
        } else if (key.compareTo(node.key) > 0) {
            node.right = add(node.right, key, value);
        } else {
            node.value = value;
        }
        
        // 更新height
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
        // 计算平衡因子
        int balanceFactor = getBalanceFactor(node);
        // 平衡维护,插入的元素在不平衡的节点的左侧的左侧 LL
        if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {
            return rightRotate(node);
        }
        // 平衡维护,插入的元素在不平衡的节点的右侧的右侧 RR
        if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {
            return leftRotate(node);
        }
        // 平衡维护,插入的元素在不平衡的节点的左侧的右侧 LR
        if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }
        // 平衡维护,插入的元素在不平衡的节点的右侧的左侧 RL
        if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }
        return node;
    }


    private Node rightRotate(Node y) {
        Node x = y.left;
        Node T3 = x.right;
        x.right = y;
        y.left = T3;
        // 更新height
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        return x;
    }

    private Node leftRotate(Node y) {
        Node x = y.right;
        Node T2 = x.left;
        x.left = y;
        y.right = T2;

        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        return x;
    }

    private int getBalanceFactor(Node node) {
        if (node == null) {
            return 0;
        }
        return getHeight(node.left) - getHeight(node.right);
    }

    // 判断该二叉树是不是一颗平衡搜索树
    public boolean isBST() {
        ArrayList<K> keys = new ArrayList<>();
        inOrder(root, keys);
        for (int i = 1; i < keys.size(); i++) {
            if (keys.get(i - 1).compareTo(keys.get(i)) > 0) {
                return false;
            }
        }
        return true;
    }

    // 判断以Node为节点的二叉树是不是一颗平衡二叉树
    public boolean isBalanced() {
        return isBalanced(root);
    }

    private boolean isBalanced(Node node) {
        if (node == null) {
            return true;
        }
        int balanceFactor = getBalanceFactor(node);
        if (balanceFactor > 1) {
            return false;
        }
        return isBalanced(node.left) && isBalanced(node.right);
    }

    private void inOrder(Node node, ArrayList<K> keys) {
        if (node == null) {
            return;
        }
        inOrder(node.left, keys);
        keys.add(node.key);
        inOrder(node.right, keys);

    }

    private Node getNode(Node node, K key) {
        if (node == null) {
            return null;
        }
        if (key.compareTo(node.key) < 0) {
            return getNode(node.left, key);
        } else if (key.compareTo(node.key) > 0) {
            return getNode(node.right, key);
        } else {
            return node;
        }
    }

    public V get(K key) {
        Node node = getNode(root, key);
        return node == null ? null : node.value;
    }

    public void set(K key, V value) {
        Node node = getNode(root, key);
        if (node == null) {
            throw new IllegalArgumentException(key + "doesn't exist !");
        }
        node.value = value;
    }

    public V remove(K key) {
        Node node = getNode(root, key);
        if (node != null) {
            root = remove(root, key);
            return node.value;
        }
        return null;
    }

    private Node remove(Node node, K key) {
        if (node == null) {
            return null;
        }
        Node retNode;
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            retNode = node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            retNode = node;
        } else {
            // 3种情况
            // 待删除节点左子树为空
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                retNode = rightNode;
            } else if (node.right == null) {
                // 待删除节点右子树为空
                Node leftNode = node.left;
                node.left = null;
                size--;
                retNode = leftNode;
            } else {
                // 待删除节点左右子树均不为空的情况
                // 找到比待删除节点大的最小节点，即待删除节点右子树的最小节点。
                // 用这个节点顶替待删除节点的位置
                Node successor = minimum(node.right);
                // 这里我们进行了删除size进行了减操作
                successor.right = remove(node.right, successor.key);
                successor.left = node.left;
                node.left = node.right = null;
                retNode = successor;
            }
        }

        if (retNode == null) {
            return null;
        }

        // 更新height
        retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
        // 计算平衡因子
        int balanceFactor = getBalanceFactor(retNode);

        // 平衡维护,插入的元素在不平衡的节点的左侧的左侧 LL
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0) {
            return rightRotate(retNode);
        }
        // 平衡维护,插入的元素在不平衡的节点的右侧的右侧 RR
        if (balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0) {
            return leftRotate(retNode);
        }
        // 平衡维护,插入的元素在不平衡的节点的左侧的右侧 LR
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) < 0) {
            retNode.left = leftRotate(retNode.left);
            return rightRotate(retNode);
        }
        // 平衡维护,插入的元素在不平衡的节点的右侧的左侧 RL
        if (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0) {
            retNode.right = rightRotate(retNode.right);
            return leftRotate(retNode);
        }
        return retNode;
    }

    // 最小值
    public V minimum() {
        if (size == 0) {
            throw new IllegalArgumentException("BST is empty");
        }
        return minimum(root).value;
    }

    // 返回已node为根的二分搜索树的最小值所在的节点
    private Node minimum(Node node) {
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }
}

实现Queue

发表于 2018-08-16

队列也是一种线性结构
相比数组，队列的对应操作是数组的子集
只能从一端添加元素，从另一端取出元素

Queue

public interface Queue<E> {
    void enqueue(E e);
    E dequeue();
    E getFront();
    int getSize();
    boolean isEmpty();
}

阅读全文 »

Java基础

发表于 2018-08-13

对学习的知识进行回顾和总结

阅读全文 »