jdbcTemple使用用来查询

src/main/java/ltass/staudy/spring/data/jpa/base/BaseJdbcDao.java

@@ -0,0 +1,20 @@
+package ltass.staudy.spring.data.jpa.base;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.BeanPropertyRowMapper;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import java.util.List;
+
+public class BaseJdbcDao {
+    @Autowired
+    JdbcTemplate jdbcTemplate;
+
+    public <T> List<T> query(String sql, Class T){
+        return jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(T));
+    }
+
+    public Object queryForObject(String sql, Class T){
+        return jdbcTemplate.queryForObject(sql,T);
+    }
+}

src/main/java/ltass/staudy/spring/data/jpa/controller/JdbcController.java

@@ -0,0 +1,33 @@
+package ltass.staudy.spring.data.jpa.controller;
+
+import com.alibaba.fastjson.JSON;
+import ltass.staudy.spring.data.jpa.entity.User;
+import ltass.staudy.spring.data.jpa.jdbc.UserJdbcDao;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class JdbcController {
+    @Autowired
+    UserJdbcDao userJdbcDao;
+
+    @GetMapping("/user/find/email/{email}")
+    public String findByEmail(@PathVariable(name = "email") String email){
+        return JSON.toJSONString(userJdbcDao.findByEmail(email));
+    }
+
+    @GetMapping("/user/count/email/{email}")
+    public String countByEmail(@PathVariable(name = "email") String email){
+        return JSON.toJSONString(userJdbcDao.countByEmail(email));
+    }
+
+    @GetMapping("/user/find/entity")
+    public String countByEntity(){
+        User user = new User();
+        user.setEmail("email");
+        user.setDelFlag(0);
+        return JSON.toJSONString(userJdbcDao.findByEntity(user));
+    }
+}

src/main/java/ltass/staudy/spring/data/jpa/jdbc/UserJdbcDao.java

@@ -0,0 +1,12 @@
+package ltass.staudy.spring.data.jpa.jdbc;
+
+import ltass.staudy.spring.data.jpa.entity.User;
+
+import java.util.List;
+
+public interface UserJdbcDao {
+
+    List<User> findByEntity(User entity);
+    List<User> findByEmail(String email);
+    int countByEmail(String email);
+}

src/main/java/ltass/staudy/spring/data/jpa/jdbc/impl/UserJdbcDaoImpl.java

@@ -0,0 +1,81 @@
+package ltass.staudy.spring.data.jpa.jdbc.impl;
+
+import cn.hutool.core.util.ReferenceUtil;
+import cn.hutool.core.util.ReflectUtil;
+import cn.hutool.core.util.StrUtil;
+import lombok.extern.slf4j.Slf4j;
+import ltass.staudy.spring.data.jpa.base.BaseJdbcDao;
+import ltass.staudy.spring.data.jpa.entity.User;
+import ltass.staudy.spring.data.jpa.jdbc.UserJdbcDao;
+import ltass.staudy.spring.data.jpa.sql.SelectBuilder;
+import ltass.staudy.spring.data.jpa.sql.WhereHelper;
+import org.springframework.stereotype.Service;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+@Slf4j
+public class UserJdbcDaoImpl extends BaseJdbcDao implements UserJdbcDao {
+
+    /**
+     * 无任何赋值的情况返回 EMPTY LIST
+     * @param entity
+     * @return
+     */
+    @Override
+    public List<User> findByEntity(User entity) {
+        Field[] fields = ReflectUtil.getFields(entity.getClass());
+        boolean allNull = true;
+        SelectBuilder selectBuilder = new SelectBuilder();
+        selectBuilder.from("users");
+        for(int i=0;i<fields.length;i++){
+            Object value = ReflectUtil.getFieldValue(entity,fields[i]);
+            if(value!=null){
+                allNull = false;
+                selectBuilder.where(WhereHelper.create(StrUtil.toUnderlineCase(fields[i].getName()),"=",value));
+            }
+            log.info(fields[i].getName() + " = "+ value);
+        }
+
+        if(allNull){
+            return new ArrayList<>();
+        }
+        String rawSql = selectBuilder.toString();
+
+        log.info("user select sql : " + rawSql);
+
+        List<User> userList = query(rawSql,User.class);
+
+        return userList;
+    }
+
+    @Override
+    public List<User> findByEmail(String email) {
+        SelectBuilder selectBuilder = new SelectBuilder();
+        selectBuilder.from("users");
+        selectBuilder.where(WhereHelper.create("email","=",email));
+
+        String rawSql = selectBuilder.toString();
+
+        log.info("user select sql : "+rawSql);
+
+        List<User> userList = query(rawSql,User.class);
+
+        return userList;
+    }
+
+    @Override
+    public int countByEmail(String email) {
+        SelectBuilder selectBuilder = new SelectBuilder();
+        selectBuilder.column("count(*)");
+        selectBuilder.from("users");
+        selectBuilder.where(WhereHelper.create("email","=",email));
+
+        String rawSql = selectBuilder.toString();
+        log.info("user select sql : "+rawSql);
+
+        return (int) queryForObject(selectBuilder.toString(),Integer.class);
+    }
+}

src/main/java/ltass/staudy/spring/data/jpa/sql/AbstractSqlBuilder.java

@@ -0,0 +1,24 @@
+package ltass.staudy.spring.data.jpa.sql;
+
+import java.util.List;
+
+/**
+ * 参考了别人的代码
+ * url  https://github.com/jkrasnay/sqlbuilder
+ */
+public abstract class AbstractSqlBuilder {
+    protected void appendList(StringBuilder sql, List<?> list, String init, String sep) {
+
+        boolean first = true;
+
+        for (Object s : list) {
+            if (first) {
+                sql.append(init);
+            } else {
+                sql.append(sep);
+            }
+            sql.append(s);
+            first = false;
+        }
+    }
+}

src/main/java/ltass/staudy/spring/data/jpa/sql/SelectBuilder.java

@@ -0,0 +1,249 @@
+package ltass.staudy.spring.data.jpa.sql;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 参考了别人的代码
+ * url  https://github.com/jkrasnay/sqlbuilder
+ */
+public class SelectBuilder extends AbstractSqlBuilder implements Cloneable, Serializable {
+
+    private static final long serialVersionUID = 1;
+
+    private boolean distinct;
+
+    private List<Object> columns = new ArrayList<Object>();
+
+    private List<String> tables = new ArrayList<String>();
+
+    private List<String> joins = new ArrayList<String>();
+
+    private List<String> leftJoins = new ArrayList<String>();
+
+    private List<String> wheres = new ArrayList<String>();
+
+    private List<String> groupBys = new ArrayList<String>();
+
+    private List<String> havings = new ArrayList<String>();
+
+    private List<SelectBuilder> unions = new ArrayList<SelectBuilder>();
+
+    private List<String> orderBys = new ArrayList<String>();
+
+    private int limit = 0;
+
+    private int offset = 0;
+
+    private boolean forUpdate;
+
+    private boolean noWait;
+
+    public SelectBuilder() {
+
+    }
+
+    public SelectBuilder(String table) {
+        tables.add(table);
+    }
+
+    /**
+     * Copy constructor. Used by {@link #clone()}.
+     *
+     * @param other
+     *            SelectBuilder being cloned.
+     */
+    protected SelectBuilder(SelectBuilder other) {
+
+        this.distinct = other.distinct;
+        this.forUpdate = other.forUpdate;
+        this.noWait = other.noWait;
+
+        for (Object column : other.columns) {
+            if (column instanceof SubSelectBuilder) {
+                this.columns.add(((SubSelectBuilder) column).clone());
+            } else {
+                this.columns.add(column);
+            }
+        }
+
+        this.tables.addAll(other.tables);
+        this.joins.addAll(other.joins);
+        this.leftJoins.addAll(other.leftJoins);
+        this.wheres.addAll(other.wheres);
+        this.groupBys.addAll(other.groupBys);
+        this.havings.addAll(other.havings);
+
+        for (SelectBuilder sb : other.unions) {
+            this.unions.add(sb.clone());
+        }
+
+        this.orderBys.addAll(other.orderBys);
+    }
+
+    /**
+     * Alias for {@link #where(String)}.
+     */
+    public SelectBuilder and(String expr) {
+        return where(expr);
+    }
+
+    public SelectBuilder column(String name) {
+        columns.add(name);
+        return this;
+    }
+
+    public SelectBuilder column(SubSelectBuilder subSelect) {
+        columns.add(subSelect);
+        return this;
+    }
+
+    public SelectBuilder column(String name, boolean groupBy) {
+        columns.add(name);
+        if (groupBy) {
+            groupBys.add(name);
+        }
+        return this;
+    }
+
+    public SelectBuilder limit(int limit, int offset) {
+        this.limit = limit;
+        this.offset = offset;
+        return this;
+    }
+
+    public SelectBuilder limit(int limit) {
+        return limit(limit, 0);
+    }
+
+    @Override
+    public SelectBuilder clone() {
+        return new SelectBuilder(this);
+    }
+
+    public SelectBuilder distinct() {
+        this.distinct = true;
+        return this;
+    }
+
+    public SelectBuilder forUpdate() {
+        forUpdate = true;
+        return this;
+    }
+
+    public SelectBuilder from(String table) {
+        tables.add(table);
+        return this;
+    }
+
+    public List<SelectBuilder> getUnions() {
+        return unions;
+    }
+
+    public SelectBuilder groupBy(String expr) {
+        groupBys.add(expr);
+        return this;
+    }
+
+    public SelectBuilder having(String expr) {
+        havings.add(expr);
+        return this;
+    }
+
+    public SelectBuilder join(String join) {
+        joins.add(join);
+        return this;
+    }
+
+    public SelectBuilder leftJoin(String join) {
+        leftJoins.add(join);
+        return this;
+    }
+
+    public SelectBuilder noWait() {
+        if (!forUpdate) {
+            throw new RuntimeException("noWait without forUpdate cannot be called");
+        }
+        noWait = true;
+        return this;
+    }
+
+    public SelectBuilder orderBy(String name) {
+        orderBys.add(name);
+        return this;
+    }
+
+    /**
+     * Adds an ORDER BY item with a direction indicator.
+     *
+     * @param name
+     *            Name of the column by which to sort.
+     * @param ascending
+     *            If true, specifies the direction "asc", otherwise, specifies
+     *            the direction "desc".
+     */
+    public SelectBuilder orderBy(String name, boolean ascending) {
+        if (ascending) {
+            orderBys.add(name + " asc");
+        } else {
+            orderBys.add(name + " desc");
+        }
+        return this;
+    }
+
+    @Override
+    public String toString() {
+
+        StringBuilder sql = new StringBuilder("select ");
+
+        if (distinct) {
+            sql.append("distinct ");
+        }
+
+        if (columns.size() == 0) {
+            sql.append("*");
+        } else {
+            appendList(sql, columns, "", ", ");
+        }
+
+        appendList(sql, tables, " from ", ", ");
+        appendList(sql, joins, " join ", " join ");
+        appendList(sql, leftJoins, " left join ", " left join ");
+        appendList(sql, wheres, " where ", " and ");
+        appendList(sql, groupBys, " group by ", ", ");
+        appendList(sql, havings, " having ", " and ");
+        appendList(sql, unions, " union ", " union ");
+        appendList(sql, orderBys, " order by ", ", ");
+
+        if (forUpdate) {
+            sql.append(" for update");
+            if (noWait) {
+                sql.append(" nowait");
+            }
+        }
+
+        if(limit > 0)
+            sql.append(" limit " + limit);
+        if(offset > 0)
+            sql.append(", " + offset);
+
+        return sql.toString();
+    }
+
+    /**
+     * Adds a "union" select builder. The generated SQL will union this query
+     * with the result of the main query. The provided builder must have the
+     * same columns as the parent select builder and must not use "order by" or
+     * "for update".
+     */
+    public SelectBuilder union(SelectBuilder unionBuilder) {
+        unions.add(unionBuilder);
+        return this;
+    }
+
+    public SelectBuilder where(String expr) {
+        wheres.add(expr);
+        return this;
+    }
+}

src/main/java/ltass/staudy/spring/data/jpa/sql/SubSelectBuilder.java

@@ -0,0 +1,34 @@
+package ltass.staudy.spring.data.jpa.sql;
+
+/**
+ * 参考了别人的代码
+ * url  https://github.com/jkrasnay/sqlbuilder
+ */
+public class SubSelectBuilder extends SelectBuilder {
+
+    private String alias;
+
+    public SubSelectBuilder(String alias) {
+        this.alias = alias;
+    }
+
+    protected SubSelectBuilder(SubSelectBuilder other) {
+        super(other);
+        this.alias = other.alias;
+    }
+
+    @Override
+    public SubSelectBuilder clone() {
+        return new SubSelectBuilder(this);
+    }
+
+    @Override
+    public String toString() {
+        return new StringBuilder()
+                .append("(")
+                .append(super.toString())
+                .append(") as ")
+                .append(alias)
+                .toString();
+    }
+}

src/main/java/ltass/staudy/spring/data/jpa/sql/WhereHelper.java

@@ -0,0 +1,17 @@
+package ltass.staudy.spring.data.jpa.sql;
+
+public class WhereHelper {
+
+    public static String create(String column ,String compareType,Object value){
+        StringBuilder sb = new StringBuilder();
+        sb.append(column).append(" ");
+        sb.append(compareType).append(" ");
+        if(value instanceof String){
+            sb.append("'").append(value).append("'");
+        }else{
+            sb.append(value);
+        }
+
+        return sb.toString();
+    }
+}