总体上分为三个步骤：

1. 构建空白窗体，设计要查询的字段名称等输入框

 1.1. 点击“创建”➡“空白窗体” 将出现一个什么组件、按钮都没有的空白窗体， 然后点击“设计”，将会转到控件选择按钮。

1.2. 转到“设计”菜单， 我们将主要用到红圈中的两个控件，1是文本框，2是按钮

1.3. 先选中文本框，然后点一下窗体内的虚线框内的任意位置，然后出现“文本框向导。第一步是设置文本框内输入文字时的字体、大小等格式。（如果调大字体，再后记的调整中，要加高输入框才能完全显示，不会自动适应， 这一点要注意！！）

1.4. 下一步，会出现输入法设置选项， 让其保持默认的随意即可。

1.5  再下一步，出现的是设置文本框的名称。 一般命名为我们要查找的 数据所属于的字段的字段名。 比如我们要查找知识产权的名称信息，则命名为： 知识产权名称。将会出现 知识产权名称： 紧跟输入框的格式。 你也可以多添加几个文本框，形成多个搜索条件，后继可以设置为and 以及 or 关系。

新添加的文本框如下所示：

 点击最左上角的，保存按钮，将出现为我们苏军哦建的窗体进行命名的对话框，为它起一个辨识度较高的名字。   到这里为止，完成了第一步！ 

2.构建符合查询需要的 查询，用于对要查找的内容进行整合，以便快速得出查询结果，同时将查询作为查询窗体的子窗体

2.1  类似上一步的操作。不过，我们选择以查询向导的方式来生成 ”查询“ 这种Access对象。

2.2 我们这里选择”简单查询向导“即可满足要求

 2.3 然后将需要集合显示出来的字段，选入并添加到右侧的位置。

2.4 还可以选择从哪个数据表添加字段，实现跨表 ”查询“，将多个数据表中的内容，集中显示到 一个”查询“ 对象的结果中。我们这里仅仅选择一个表作为例子

 2.5 下一步之后，到了为”查询“进行命名的步骤。 也就是左侧导航栏中，查询 下面所显示的”查询“ 对象的名称。 我们这里直接用ABC作为示例

最终建成的 ”查询“ 对象 ABC，以及导航栏右侧，所显示的，该查询所形成的结果。我们后面第三步添加的搜索按钮，输入要查找的关键字后，显示的内容格式将和ABC所显示的内容格式相同。 也就是说，搜索，将会对”查询“对象 ABC中所显示的内容进行搜索。

2.6 设置 查询 对象中   要用于搜索用的字段的动作。

    进入ABC 查询对象的设计视图，选则要用于搜索用的字段，在下方条件中右击，选择“生成器”，打开“表达式生成器”，编写规则。要先编辑模糊查询功能，再拖成子窗体才行!!!!!!

Like"*"& Forms![ABC 子窗体]![软著名称] &"*"

点击确定后，保存，回到“数据表视图。

 2.7 选“查询用测试页面”窗体，进入设计视图，然后拖动左侧导航栏中的 ABC 查询对象到 “查询用测试页面 ” 窗体中， 作为子窗体，并保存

3.  在搜索窗体中添加 查询按钮，并设置查找函数，实现查找功能

3.1 再次进入 “查询用测试页面”窗体的设计视图 ，点击上方的设计，这次是添加按钮控件。选择，点击要添加的按钮的位置，出现对话框，主要是选择和设定名称。

 最终在窗体中应当显示下图所示的样子

 3.2 为按钮设置动作属性，即点击按钮，开始搜索你所输入的字段中内容的关键字

 完整的命令：

 Me.ABC_子窗体.Requery

然后保存，关闭编辑窗口

3.4  保存整个查询 窗体， 然后切换回 窗体视图，就可以输入查询字段，搜索相关内容了. 我们这里是测试了一个文本框，要实现对多个字段的搜索，需要在增加搜索字段和 设置查询中搜索动作时，多几个对应的操作即可

最近在学习springboot使用jpa操作数据库，总结一下。
Dao层创建与JavaBean对应的接口，继承JpaRepository<K，E>接口

@Repository
public interface AccountDao extends JpaRepository<Account,Integer>{}
//Account对应的是JavaBean实体类，Integer是实体类主键的类型

无需创建接口的实现类

个人学习到的jpa的几种查询方法：
1、jpa自带的方法：

使用的编程语言是Kotlin
//主要记录分页和排序
//service层
class AccountServiceImpl:AccountService{
	@Autewired
	lateinit var accountDao:AccountDao
	override fun queryOnLoad(apu: AccountPageUtil): Map<String, Any?> {
		//创建排序对象
        val sort:Sort=Sort.by(Sort.Direction.ASC,"id")
        //创建分页对象
        val page:Pageable=PageRequest.of(apu.getStart(),apu.rows,sort)
        val map = hashMapOf<String,Any?>()
        //通过findAll方法进行分页查询
        var pageResult=accountDao.findAll(page)
        //findAll(Pageable)返回的是page对象，其中包含了分页所需要的总页数、总信息条数、每页中的对象等资源。可以查看源码获取所需要的信息
        //分页的结果
        map["rows"]=pageResult.content  
        //分页总数
        map["total"]=pageResult.totalPages
        return map
    }
}

2、jpa可以通过方法名进行查询

Dao层的接口
@Repository
interface SubjectDao:JpaRepository<Subject,Int>{
    /**
     * 根据Clazz查询
     */
    fun findByClazz(clazz:String,pageable:Pageable):List<Subject>

    /**
     * 根据sid精确查询单个对象
     */
    fun findBySid(id:Int):Subject
}    

推荐博客：http://www.ityouknow.com/springboot/2016/08/20/spring-boo-jpa.html

3、自定义SQL查询语句进行查询

Dao层的接口
@Repository
interface SubjectDao:JpaRepository<Subject,Int>{
	@Query(value="select sid as sid,sname as sname,slevel as slevel,clazz as clazz,pname as pname,pid as pid from Subject where sid like %?1%) ")
    fun myFindBySidLike(sid:Int,pageable: Pageable):List<Map<String,Any>>
}

在这里有几个注意点

• @Query中有一个属性：nativeQuery = true 添加该属性等于true则是原生SQL语句查询，不添加则是HQL语句（Hibernate面向对象的查询）
• like模糊查询时可在后面直接加%
• 方法中给的参数类型必须和实体类中定义的类型一样，否则会报类型不一致的错
• 方法的返回值好像只能返回List<Map<K,V>>类型（因为我只试过返回Page类型和List类型，都是类型不对）。Map中的Key就是查询语句中的别名，所以这里添加了别名。
• 方法名不能是findBySidLike，因为这样他就不会执行自己写的SQL语句。

4、复杂的条件拼接查询
看到其他人的博客中说，Dao层接口再继承一个接口JpaSpecificationExecutor<实体类>

Dao层
@Repository
interface SubjectDao:JpaRepository<Subject,Int> , JpaSpecificationExecutor<Subject> {}

private Specification<Db1NewsFilesEntity> countByAppidAndKwAndSearchId(String appId, String wk , String searchId){
        return new Specification<Db1NewsFilesEntity>() {
            @Override
            public Predicate toPredicate(Root<Db1NewsFilesEntity> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
            	//创建存放Predicate对象的集合
                List<Predicate> list = new ArrayList<>();
               /*用于关联查询join方法的第二个参数可以设置
                JoinType.LEFT、JoinType.RIGHT、JoinType.INNER*/
                Join<Db1NewsFilesEntity, Db1NewsItemsEntity> join = 
                	root.join("newsItem", JoinType.INNER);
                //以下为添加条件
                list.add(criteriaBuilder.equal(root.get("appId"),appId));
                list.add(criteriaBuilder.equal(root.get("img"),true));
                list.add(criteriaBuilder.equal(join.get("appId"),appId));
                list.add(criteriaBuilder.equal(join.get("isOk"),2));
                list.add(criteriaBuilder.isNotNull(join.get("topImgId")));
                //判断并拼接条件
                if(!StringUtils.isEmpty(searchId)){
                    list.add(criteriaBuilder.equal(join.get("searchId"),searchId));
                }
                if(!StringUtils.isEmpty(wk)){
                    list.add(criteriaBuilder.like(join.get("ItemTitle"),"%"+wk+"%"));
                }
                Predicate[] p = new Predicate[list.size()];
                query.where(criteriaBuilder.and(list.toArray(p)));
                return query.getRestriction();
            }
        };
    }
    //此段代码摘抄自网络：https://blog.csdn.net/qq587492/article/details/81629689

写上上面的代码我主要是想说说他的弊端，我原以为他是万能的，结果个人认为还是比较局限的。

• 它是一种完全面向对象的。如果两个表之间没有明确的关联关系（在属性上标注OneToOne、OneToMany等）时，关联查询是不能实现的，肯定是类型对不上，等待着的就是各种报错。
• 他不能实现自定义字段查询（投影查询），每次查询时会把所有的字段都差出来。
• 他只能用在findAll方法上，使用自定义的方法，根本不回去拼接，而是去执行了自定义的方法。

所以我觉得稍微复杂一点的查询就要费事了。

于是继续众里寻他在百度，终于找到了你想怎样就怎样的方法。

1. 在service层中放这么一个东西。

@PersistenceContext
   lateinit var em: EntityManager

java中是这么写的：

@PersistenceContext
private EntityManager em;

他有一些创建Query对象的方法，有了Query对象，就可以自己拼接条件查询了。
下面放上我使用它的一点代码：

/**
     * 自定义拼接条件查询
     */
    fun predicateQuery(em: EntityManager,apu: AccountPageUtil): MyResult<ResultAccount> {
        var baseSQL="select new com.sandrain.financial.entity.ResultAccount(a.id,a.createDate,a.proofNum,a.digest,a.come,a.go,a.balance,a.orientation,a.clazz,b.sname,c.sname) from Account a left outer join Subject b on a.subject=b.sid left outer join Subject c on a.sideSubject=c.sid where 1=1"
        var comditionalSQL=""
        var countSQL="select count(id) from Account a where 1=1"
        //map用来组装SQL占位符和对应的值
        var map= hashMapOf<String,Any>()
        if(!apu.startDate.equals("")&&!apu.endDate.equals("")){
            println("拼接条件查询：开始时间不为空，结束时间不为空")
            comditionalSQL+=" and (a.createDate between :startdate and :enddate)"
            map["startdate"]=apu.startDate
            map["enddate"]=apu.endDate
        }else if(!apu.startDate.equals("")&&apu.endDate.equals("")){
            println("拼接条件查询：开始时间不为空，结束时间为空")
            comditionalSQL+=" and (a.createDate between :startdate and :enddate)"
            map["startdate"]=apu.startDate
            map["enddate"]="${LocalDate.now()}"//相当于Java中的""+LocalDate.now()
        }else if(apu.startDate.equals("")&&!apu.endDate.equals("")){
            println("拼接条件查询：开始时间为空，结束时间不为空")
            comditionalSQL+=" and (a.createDate between :startdate and :enddate)"
			//相当于java中的拼接字符串LocalDate.now().year+"-"+LocalDate.now().monthValue+"-01"       
            map["startdate"]="${LocalDate.now().year}-${LocalDate.now().monthValue}-01"
            map["enddate"]=apu.endDate
        }else{
            println("拼接条件查询：开始时间为空，结束时间为空")
            comditionalSQL+=" and (a.createDate between :startdate and :enddate)"
            map["startdate"]="${LocalDate.now().year}-${LocalDate.now().monthValue}-01"
            map["enddate"]="${LocalDate.now()}"
        }
        if (apu.digest!=""){
            println("拼接条件查询：digest不为空")
            comditionalSQL+=" and a.digest=:digest"
           map["digest"]="${apu.digest}"
        }
        if(apu.clazz!=""){
            println("拼接条件查询：clazz不为空")
            comditionalSQL+=" and a.clazz=:clazz"
            map["clazz"]="${apu.clazz}"
        }
        if(apu.subject!=null) {
            println("拼接条件查询：关联subject不为空")
            comditionalSQL+=" and a.subject=:subject"
            map["subject"]=apu.subject!!
        }
        //组装SQL
        var resSQL="${baseSQL}${comditionalSQL}"
        var countSQL="${countSQL}${comditionalSQL}"
        //创建查询对象
        /*这里是重点，将SQL放入方法中，创建一个查询对象，确切的说应该是HQL，
        他接收的也是Hibernate查询语句（我写原生SQL报错）。重点是，SQL是自己写的，
        这就灵活了很多。性能方面没有关注*/
        var res=em.createQuery(resSQL)
        var countRes=em.createQuery(countSQL)
        //创建封装结果集的对象
        var result=MyResult.of<ResultAccount>()
        //设置分页，注意，分页只能用这种方式，不能写在SQL中，否则报错
        res.setFirstResult(apu.getStart())
        res.setMaxResults(apu.rows)
        //添加参数，此处我用了kotlin的方式将占位符和参数一一对应放入Query对象中
        for ((index,ele) in map){
            res.setParameter(index,ele)
            countRes.setParameter(index,ele)
        }
        //组装结果集
        /*
        此处注意的是：如果用普通是SQL样式查询，如："select a,b,c from d where ..."
        他返回的不是键值对形式对象，有些难以控制。
        所以我在SQL中使用了Hibernate的投影查询方式：
        "select new com.sandrain.financial.entity.ResultAccount(a,b,c) from d where ..."
        com.sandrain.financial.entity.ResultAccount是我自定义的一个返回结果集的类，
        这个类要有一个和查询的字段类型一一对应的构造方法。
        那么返回的就是一个该对象的集合。当然需要强转一下
        a as ResultAccount就是将a强转为ResultAccount
		*/
        for (a in res.resultList){
            result.rows.add(a as ResultAccount)
        }
        //查询一个对象时使用singleResult()方法获得
        //查询一堆对象时用resultList()方法获得，
        //查询的数值返回的是伪Long型，所以先转为Long型，再转为Integer
        result.total=(countRes.singleResult as Long).toInt()
        return result
    }

//创建HQL语句
@PersistenceContext
 private EntityManager em;
String hql="select a,b from C where d=:e "// :e是占位符，也相当于给占位符起一个名字
//通过HQL语句创建query对象
Query query=em.createQuery(hql)
//给条件添加值，占位符不能使用？的形式
//query.setParameter(占位符，值)
query.setParameter("e",255)
//获取结果
List<C> list=query.getResultList
//遍历结果集组装想要的结果...

如有不对之处还请大神告知一二

2019 access创建数据表、查询和窗体

打开access，在菜单栏选择创建，我们可以看到有 “表格” 、“查询”、“窗体”等模块，我们可以通过这些按钮来进行表的创建、查询设计、窗体的创建。

$$图一$$

1.创建表

1）点击 “表”

点击图一的 “表” ，出现下图，其中第一列 ID 是表默认的一个自增序列

$$图二$$
单击 “单击已添加”，出现下图，你可以选择你想要添加的数据类型，如：“数字”、“短文本”等，其余数据补充与 EXCEL 类似
$$图三$$
如果你想删除 ID 这一列号，右击上图（图三）箭头处，出现下图，选择设计视图，过程中可能会弹出保存页面，输入表的名字，保存即可。

$$图四$$
接着，我们进入到了表的设计视图，如下（图五），在这个视图下我们可以删除 ID列，也可以添加其他列、设置主键

$$图五$$
右击下图(图六)箭头处,可以选择取消和设置这一列为主键,如果想要设置多个主键,可以按住"Ctrl"同时选中多个标签,设置为主键.
$$图六$$
如下图(图七), 我已创建好了三个数据表, “boats” 表是船的信息表，其中包括bname(船的名字)、bid(船的编号)；“sailors”表是水手的表，即可以预定船的顾客的信息，其中包括sid(水手编号)、sname(水手名字)、rating（水手等级）、age（水手年龄）；“reserves”表是船的预定表，其中包括，id(预定号)、sid(水手编号)、bid(船的编号)、date(预定的日期)，我们可以对这三个数据表建立表与表之间的关系。

$$图七$$
点击菜单栏的 “数据库工具” , 接着点击出现的 “关系” ,出现下图(图八)

$$图八$$
点击上图中的 “显示表”, 出现我们刚刚建立的三个表, 如下,我们可以双击选择或者选中该表并单击页面的 “添加” 按钮来添加一个表 .

$$图九$$
现在我们选中三个表来创建关系, 选中一个表中的任一标签拖动到另一个表即可出现编辑关系页面, 选择两个表中相同的标签, 即可成功创建它们之间的关系, 如下图(图十),选择结束之后单击确定即可.
$$图10$$

2.创建查询

建立好表和关系后,我们就可以根据它们新建查询了, 点击图一中的 “查询设计”( 菜单栏下的"创建" ), 就进入了查询设计试图页面 , 同样我们可以选择我们要基于哪些表来查询,如下图

$$图11$$
我们选择刚刚建好的三张表，在下图中的 “字段” 中选择你要限定的标签，在 “条件”位置填写你对这个标签值的限定条件，如下图（图12）

$$图12$$
确定好条件之后，点击上图最左侧的 “视图”，选择数据表视c图，就可以看到该条件下的查询结果了。

$$图13$$
除了上述的创建查询的方法，你还可以通过：

1. 在图一上（菜单栏“创建”下）的 “查询向导” 的指示下一步一步完成查询
2. 在图13中最左端的视图下选择SQL视图，用SQL语言写查询条件，生成数据表，如：图14
   $$图14$$

3.创建窗体

在图一（菜单栏“创建”下）选择空白窗体，到如下图:

$$图15$$
选择上图右侧 “字段列表” 中的 “显示所有表”，双击选择你想要显示的信息，如下：

$$图16$$
创建出来的这个窗口作为一个要显示的弹窗，你可以直接在下方的搜索栏里面搜索相关的数据，也可以将它作为其他表的一个特定显示窗口，保存为窗体信息查询列表。例如，你想要在一个窗口上输入一只船的名字，然后就能显示出它的颜色及编号，你就可以将上面的窗体作为它要弹出的窗体。现在，你需要创建一个新的窗口，作为输入船的名字的窗体，并将它输入的值与该窗体的船的名字连接起来。
再创建一个新的 “空白窗体”，如上，选择 “窗体布局” 下的 “设计”，如下：

$$图17$$
单击选择上图红箭头指向的 “ 文本框”，点击它，在窗体上画文本框，会弹出来一个向导页面，可以设置这个文本框的字体、输入法、对齐参数等等，在最后页面输入你的文本框的名字，如: text0, 单击完成。

$$图17$$
接着单击下图中红色箭头指向的 “按钮” 图标，

$$图18$$
在窗体内画按钮，弹出页面，选择 “窗体操作” ，选择 “ 打开窗体”，单击下一步，

$$图19$$
选择你将要弹出的窗体，我们要显示船的信息，就选择刚刚创建的 “窗体信息查询列表”，单击下一步

我们要显示是的与输入的船的名字相关的信息，选择 “打开窗体并查找要显示的特定数据”，单击下一步

选择左侧该窗体下的 “text0 ” 和 右侧窗口的船的名字 “bname”，单击红箭头指向的图标，将这两个值关联起来，单击下一步

选择在按钮上显示图片还是文字，在这里我们选择显示文字 “ 查询 ”，单击下一步

指定按钮的名称，可以采取默认，单击完成。

单击最左侧的 “视图”，选择 “窗体视图”，在 text0 文本框内输入一个船的名字 “aaaa”,单击查询

即可弹出要显示的信息，如下：
这样，我们创建窗体和弹出窗体就完成了，你可以在窗体的 “布局视图” 设置背景图片，如下：

也可以在布局视图下拖动调整按钮的位置等等，如下：