精华内容
下载资源
问答
  • Mybatis框架

    2021-04-05 21:01:22
    相当于包工队 SqlSessionFactory factory = builder.build(in);;in相当于钱 SqlSession session = factory.openSession(); 生产SqlSession使用了工厂模式,降低解耦 IUserDao mapper = session.getMapper(IUserDao....

    Mybatis框架

    1. MyBatis 框架概述

    ​ 框架(Framework)是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种
    定义认为,框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。
    简而言之,框架其实就是某种应用的半成品,就是一组组件,供你选用完成你自己的系统。简单说就是使用别人搭好的舞台,你来做表演。而且,框架一般是成熟的,不断升级的软件。

    ​ mybatis 是一个优秀的基于 java 的持久层框架,它内部封装了 jdbc,使开发者只需要关注 sql 语句本身,
    而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。
    mybatis 通过 xml 或注解的方式将要执行的各种 statement 配置起来,并通过 java 对象和 statement 中sql 的动态参数进行映射生成最终执行的 sql 语句,最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并返回。采用 ORM 思想解决了实体和数据库映射的问题,对 jdbc 进行了封装,屏蔽了 jdbc api 底层访问细节,使我们不用与 jdbc api 打交道,就可以完成对数据库的持久化操作。

    2.框架搭建

    ​ mybatis环境搭建

    ​ 第一步:创建maven工程并导入坐标

    ​ 第二步:创建实体类和dao的接口

    ​ 第三步:创建Mybatis的主配置文件 SqlMapConfig.xml 还有映射配置文件,dao下的独立配置文件。

    ​ 第四步:创建映射配置文件 IUserDao.xml

    2.1环境搭建的注意事项:

    ​ 第一个:创建IUserDao.xml和IUserDao.java是名称为了保持一致,Mybatis中他把持久层的操作接口名称和映射文件也叫做:Mapper

    ​ 所以:IUserDao和IUserMapper是一样的

    ​ 第二个:在idea中创建目录的时候,他和包是不一样的

    ​ 包创建时:cn.pluto.dao是三层

    ​ 目录在创建时:cn.pluto.dao是一级目录

    ​ 第三个:mybatis的映射文件位置西部和dao接口的包结构相同

    ​ 第四个:映射配置文件的mapper标签namespce属性的取值必须是dao接口的全限定类名。

    ​ 第五个:映射配置文件的操作配置(select),id属性的取值必须是dao接口的方法名

    ​ 开发中无须再写dao的实现类。

    2.1.2步骤:

    ​ 1.读取配置文件

    ​ 2.创建SqlSessionFactory工厂

    ​ 3.创建SqlSession

    ​ 4.创建Dao接口的代理对象

    ​ 5.执行dao中的方法

    ​ 6.释放资源

    ​ 注意事项:

    ​ 不要忘记在映射配置中告知mybatis要封装到那个实体类中配置的方式:指定实体类的全限定类名

    2.1.3mybatis基于注解的入门案例:

    ​ IUserDao.xml移除,在dao接口的方法上使用@Select注解并且指定sql语句,同时需要在SqlMapConfig.xml中的mapper配置时,使用class属性指定全限定类名

    3.自定义Mybatis的分析

    ​ mybatis在使用代理dao的方式实现增删改查时做什么事呢?

    ​ 只有两件事:

    ​ 第一:创建代理对象

    ​ 第二:在代理对象中调用selectList

    ​ 自定义mybatis能看到的类

    构建者模式:把对象的创建细节隐藏,使用者直接调用方法即可拿到对象
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); 相当于包工队
    SqlSessionFactory factory = builder.build(in);;in相当于钱
    SqlSession session = factory.openSession(); 生产SqlSession使用了工厂模式,降低解耦
    IUserDao mapper = session.getMapper(IUserDao.class); 创建Dao接口实现类使用代理模式,不修改源码的基础上对已有的方法增强
    

    PreparedStatement对象它的执行方法:

    ​ execute:他能执行CRUD中任意一种语句,返回值是一个boolean类型,表示是否有结果集。有结果集是true,没有结果集是false。

    ​ executeUpdate:他只能执行CUD语句,查询语句无法执行,它的返回值是影响数据库的行数。

    ​ executeQuery:他只能执行select语句,无法执行增删改。执行结果封装的结果集ResultSet对象。

    4.properties标签的使用

    ​ <!-- 配置properties
    可以在标签内部配置连接数据库的信息。也可以通过属性引用外部配置文件信息
    resource属性: 常用的
    用于指定配置文件的位置,是按照类路径的写法来写,并且必须存在于类路径下。
    url属性:
    是要求按照Url的写法来写地址
    URL:Uniform Resource Locator 统一资源定位符。它是可以唯一标识一个资源的位置。
    它的写法:
    http://localhost:8080/mybatisserver/demo1Servlet
    协议 主机 端口 URI

            URI:Uniform Resource Identifier 统一资源标识符。它是在应用中可以唯一定位一个资源的。
    -->
    <properties url="file:///D:/IdeaProjects/day02_eesy_01mybatisCRUD/src/main/resources/jdbcConfig.properties">
       <!-- <property name="driver" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy_mybatis"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>-->
    </properties>
    

    4.1tyoeAliases标签使用

    ​	使用typeAliases配置别名,它只能配置domain中类的别名 -->
        <typeAliases>
            <!--typeAlias用于配置别名。type属性指定的是实体类全限定类名。alias属性指定别名,当指定了别名就再区分大小写 
            <typeAlias type="cn.pluto.domain.User" alias="user"></typeAlias>
    
            <!-- 用于指定要配置别名的包,当指定之后,该包下的实体类都会注册别名,并且类名就是别名,不再区分大小写-->
            <package name="com.itheima.domain"></package>
        </typeAliases>
    带mappers中  package指定dao包的位置
    
    展开全文
  • 但应在拱圈砂浆达到设计强度后方可卸。 箱涵通道、涵洞施工流程图 路堤整修施工流程图 施工工艺 (1)测量放样,洒白灰标示出路堤两侧超填宽度,路堤顶面纵横向坡面标高采用埋砖法控制。 (2)填土路堤两侧超填的宽度...

    路基工程

    01

    拆除工程

    拆除浆砌石:18~25元/m³

    机械拆除素砼:40~60元/m³

    爆破拆除素砼:40~60元/m³

    机械拆除钢筋砼:80~90元/m³

    机械挖除水泥砼路面:20~30元/m³

    机械挖除沥青砼路面:10~15元/m³

    机械挖除碎石路面或粒料基层:10~12元/m³

    人工凿除沥青砼路面:35~50元/m³

    人工拆除路缘石:15~20元/m³

    拆除砖墙:15~20元/m³

    02

    机械土方

    挖装土方:2~2.8元/m³

    运输第1km:2.8~3.5元/m³

    增运0.5km:0.4~0.5元/m³

    碾压及路基修整(含翻挖晾晒):3~3.5元/m³

    碾压及路基修整(含翻挖晾晒):2.5~3.5元/m³

    掺灰5%处理(旋耕机、小宝马):19~23元/m³

    掺灰6%处理(旋耕机、大宝马):22~25元/m³

    每增减1%生石灰:1.9~2.5元/m³

    冲击碾压:0.12~0.15元/m³

    推土机推表土:1.0~1.8元/m³

    推土机平整弃渣场:0.5~0.8元/m³

    砍伐树木:5~8元/m³

    挖除树根:10~15元/m³

    接管吹填中粗砂:27元/m³

    一般堆载及超载填砂:25元/m³

    砂垫层(含Φ100PVC泄水管及外包反滤上工布):40元/m³

    堆载顶压填砂(沉降及加宽):26元/m³

    填砂袋(反压护道):60元/m³

    机械素土回填:5~8元/m³

    03

    路基石方

    软石(松动爆破):5.5~7元/m³

    次坚石(松动爆破):6~7.5元/m³

    特坚石、坚石(松动爆破):7~8.5元/m³

    孤石:10~12元/m³

    控制爆破增加费:5~8元/m³

    装石方:2.5~3.5元/m³

    运输第1km:3~4元/m³

    碾压石方:3~4元/m³

    增运0.5km:0.5~0.6元/m³

    添AB组料:5~6.5元/m³

    04

    路基附属工程

    干砌石边沟:45~60元/m³

    浆砌石边沟:65~75元/m³

    预制混凝土边沟:150~170元/m³

    现浇混凝土边沟:150~160元/m³

    05

    边坡防护

    干砌石:45~65元/m³

    浆砌片石护坡:60~70元/m³

    浆砌块石护坡:50~60元/m³

    砼预制块护坡:150~160元/m³

    铺草皮:3.5~5元/m³

    喷播植草:2.5~5.5元/m³

    客土喷播(10cm厚):25~27元/m³

    喷混植生:25~32元/m³

    预应力锚索:100~120元/m³

    现浇砼边坡:130~150元/m³

    Φ=22、25锚杆:8~10元/m³

    框架梁:120~170元/m³

    主动防护网:110~120元/m³

    06

    软基处理

    泥浆泵清淤:4~5元/m³

    挖掘机清楚淤泥:7~12元/m³

    砂垫层:55~60元/m³

    碎石垫层:55~60元/m³

    抛填片石:45-50元/m³

    水泥搅拌桩(Φ500mm):9~11元/m

    单管高压旋喷机(Φ500mm):50~60元/m

    单管高压旋喷机(Φ600mm):55~65元/m

    素砼桩(50cm):50~60元/m

    静压或打入桩(网点):13~18元/m

    砂桩、碎石桩(80cm):16~18元/m

    塑料排水板:0.9~1.2元/m

    土工格室:0.9~1.2元/m

    土工网垫:0.9~1.2元/m

    土工格栅:0.9~1.2元/m

    复核土工膜(含土工布):0.9~1.2元/m

    袋装砂井:1.5~2元/m

    长螺旋CFG桩(50cm):12~18元/m

    CFG桩桩帽混凝土:45~55元/m³

    CFG桩桩板混凝土:55~65元/m³

    CFG桩桩板、桩帽钢筋:400~420元/t

    07

    挡土墙

    浆砌片石护坡:50~65元/m³

    钢筋混凝土:110~130元/m³

    片石混凝土墙身:90~120元/m³

    片石混凝土基墙:45~60元/m³

    钢筋混凝土:430~480元/t

    混凝土预制块墙身:140~160元/m³

    08

    桩板挡墙

    就地灌注钢筋混凝土桩柱(地下):25~30元/m³

    就地灌注钢筋混凝土桩柱(地上):110~130元/m³

    挡土板预制:80~90元/m³

    挡土板运输1km:50~60元/m³

    挡土板安装:50~60元/m³(安装)

    钢筋:400~450元/t

    09

    抗滑桩

    挖桩土方:60~70元/m³

    石方:120~140元/m³

    护壁:120~140元/m³

    桩身:30~35元/m³

    钢筋:450~480元/t

    ab218faa2313be42f57f464f271f04ab.png

    土方路基、石方路基、路基摊铺、路基开挖、路基回填:路基的种类和工程类型复杂而多变,路基的施工方法也是各种各样。不同路基类型一般对应着不同的施工方法,而不同的方法又有不一样的施工流程。

    填土路基施工流程图

    580e300732af1173b51b6e074b2ac672.png

    施工工艺

    (1)路基每层填料铺设前,下一层底面必须石灰打格,并且挂线,以控制施工层铺厚度。

    (2)若填方分几个作业段施工,两段交接处不在同一时间填筑,则先填地段应按1:1分层留台阶。若两个地段同时填,则应分层相互交叠衔接,其搭接长度不得小于2m。

    (3)机械作业时,应根据工地地形、路基横断面形状和土方调配图等,合理地规定机械运行路线。土方集中工点,应有全面、详细的机械运行作业图。

    (4)压路机进行路基压实作业行驶速度在4km/h以内为宜,压实路线,直线段宜先两侧后中间,小半径曲线段由内侧向外侧,纵向进退式进行;横向接头,对振动压路机重叠0.4~0.5m,对三轮压路机重叠轮宽的1/2,前后相邻两区段宜纵向重叠1.0~1.5m,使路基各点都得到压实,避免土基产生不均匀沉陷。

    填挖交界处施工流程图

    74ad00b90d7eedc09029ce7b6c9a42f4.png

    结构物处回填施工流程图

    e04c25995ecd396812011380b08c49fa.png

    施工工艺

    (1)结构物回填前应在台背用油漆画好每一层的松铺厚度标志线,分层回填压实。

    (2)涵洞缺口填土,应在两侧对称均匀分层回填压实。如使用机械回填,则涵台胸腔部分及检查井周围应先用小型压实机械压实后,方可用机械进行大面积回填。

    (3)填土过程中,应防止水的浸害,回填结束后,顶部应及时封闭。

    (4)在涵洞两侧缺口填土未完成前,不得进行涵顶标高以上的填方施工。

    冲击式压路机施工流程图

    bb7e4f611223116d3a79c95284733877.png

    施工工艺

    (1)冲击式压路机最大瞬间冲击功率不小于25KJ,轮重为16T,动力不小于400马力,行走时速不小于12KM。

    (2)冲碾时注意避免对涵洞或其他构造物的损坏。

    填石路基施工流程图

    5fb1d7114b684fb95aabb4ead87b38d8.png

    施工工艺

    (1)填石路堤逐层填筑时,应安排好石料运输路线,专人指挥,按水平分层,先低后高,先两侧后中央上料,并用大功率推土机摊平。个别不平处应配合细石块、石屑找平。

    (2)当石块级配较差、料径较大、填层较厚、石块间空隙较大时,可在每层表面的空隙里扫入石渣、石屑、中粗砂,再以压力将砂冲入下部,反复数次,使空隙填满。

    (3)人工铺填石料时,应先铺填写大块石料,大面向下,小面向上,摆平放稳,再用小石块找平,石屑塞缝、最后压实。

    (4)填石路堤压实时应先两侧(即靠路肩部分)后中间,压实路线对于轮碾应纵向互相平行,反复碾压。行与行之间应重叠40-50cm,前后相邻区段应重叠1.0-1.5m。

    土质路堑开挖施工流程图

    8848213dfc48ac0e384f0ad89a4d0778.png

    软土地基施工流程图

    0c2f3d538af07b54cb3a7f2ffd49fba7.png

    河、塘、湖(库)、海地区路基施工流程图

    93b88a3c7d797a72e736aa41d3cc1038.png

    施工工艺

    (1)填料与取土:宜设置集中取土场。常水位以下路堤的施工材料,宜选用矿渣、块石、砾石等水稳性良好的材料,其粒径不宜大于30cm。

    (2)受水位涨落影响的部分,也宜选用水稳性好的材料,如具有天然级配的砂砾、卵石、粗(中)砂,石质坚硬不宜风化的片、碎石等。

    (3)严格按设计图纸及文件并根据水流对路基破坏作用的性质、程度进行防护和加固施工。当施工现场的实际情况与设计防护形式不符,应提请监理工程师设计代表变更设计。防护方式一般可采用植物防护、石砌防护、砼板防护、石笼、抛石、挡土墙等措施或综合采用两种及两种以上的措施。

    (4)山区沿河路基,应针对水流冲刷情况进行加固和防护,施工期间注意防洪,防洪工程宜在洪水期前完成;穿越地质不良陡峻沟谷时,还应查清有无泥石流影响,并相应采取排导,拦截措施。

    铺种草皮防护施工流程图

    cee572965f9f23507478fec0de8f5d9d.png

    喷播草籽防护施工流程图

    61d53335a5b1c004294da7e98941b8ed.png

    浆砌片(块)石或混凝土预制块防护施工流程图

    1dce2a0dc9d3696f91332335157067ef.png

    一般路段边沟施工流程图

    c65efb6449dccf27f75cfe50a233b2cb.png

    盲沟、渗沟施工流程图

    674b5d822b63e21bbcc3d13e72514068.png

    圆管涵施工流程图

    8ab4b36f177eae992884d16d9657b7c3.png

    倒虹吸施工流程图

    f7dc41e7b1ccc590754a94dab18381bd.png

    施工工艺

    (1)倒虹吸管施工与圆管涵的施工技术与工艺基本一致,但重点处理在管节之间的接缝处理。

    (2)倒虹吸在填土覆盖前必须做灌水试验,符合要求后,方可填土。

    盖板涵施工流程图

    e26418a017d9999ac08ec23c2fcad873.png

    拱涵施工流程图

    a80faa9d7e2af0650879ac75180a2af5.png

    施工工艺

    (1)拱涵有关砌体工程必须按砌体工程相关规范要求施工。

    (2)基坑开挖及基底承载力检测如盖板涵。

    (3)拱圈支架必须经设计验算确定,搭设拱圈时必须预留相应的预拱度,支架必须有足够的强度和刚度。

    (4)拱圈砌筑或采用砼浇筑时,应由两侧向中间同时对称进行,以防拱架失稳,进出水口的拱上端墙应待拱圈合拢砂浆强度达到设计强度的30%以上后方可进行施工。

    (5)拱圈砂浆强度达到设计强度的70%时方可拆除拱架,砂浆强度必须达到设计强度后方可进行拱上填土。

    (6)当拱架未拆除,拱圈砂浆强度达到设计强度的70%时,可进行拱顶填土。但应在拱圈砂浆达到设计强度后方可卸架。

    箱涵通道、涵洞施工流程图

    8ab4b36f177eae992884d16d9657b7c3.png

    路堤整修施工流程图

    93d207a8fd93bb8e4f3c1a39d844e252.png

    施工工艺

    (1)测量放样,洒白灰标示出路堤两侧超填宽度,路堤顶面纵横向坡面标高采用埋砖法控制。

    (2)填土路堤两侧超填的宽度应予切除,如遇边坡缺土,必须挖成台阶分层填补夯实。

    (3)边沟整修应挂线进行,如遇边沟缺损,不可随意用土贴补。

    (4)修整的路基表层厚150mm以内,松散的或半埋的尺寸大于100mm的石块,应从路基表面层移走,并按规定填平压实。

    (5)在路堑边沟和路堤拱形护坡,每隔20米应设20*20cm临时排水孔,排水孔底面低路床标高10cm,在凹形竖曲线低处应增设临时排水孔。

    (6)在路面施工前,应检查临时排水、永久排水设施是否设置、有效。

    (7)路基修整完毕后,堆弃路基范围内的废土料应予清除。

    展开全文
  • MyBatis框架

    2019-08-26 21:10:21
    构建者模式:就相当于你要修房子的时候,你自己不用修,你找来了包工队,由这个包工队修,你只需要给钱。这个包工队就相当于是构建者。 构建者模式的优势:把对象的创建细节隐藏,使得使用者直接调用方法即可拿到...

    框架:
    三层架构:
    表现层:是用于展示数据的
    业务层:是处理业务需求的
    持久层:是和数据库交互的
    3 持久层技术解决方案:
    JDBC技术:
    Connection
    PreparedStatement
    ResultSet
    Spring的JDBCTemplate:
    Spring中对jdbc的简单封装
    Apache的DBUtils:
    它和Spring的jdbcTemplate很像,也是对jdbc的简单封装
    以上这些都不是框架
    JDBC是规范
    Spring的JDBCTemplate和Apache的DBUtils 都是工具类
    4 mybatis的概述:
    mybatis是一个持久层框架,用java编写的,它封装了jdbc操作的很多细节,使开发只需要关注SQL语句本身,而无需关注注册驱动,创建连接等复杂过程,它使用了ORM思想实现了结果集的封装。

    ORM:
    Object Relational Mapping 对象关系映射
    简单的说:
    就是把数据库表和实体类及实体类的属性对应起来
    让我们可以操作实体类就实现操作数据库表。
    Mybatis的环境搭建:
    第一步:创建maven工程并导入坐标
    第二步:创建实体类和dao的接口
    第三步:创建Mybatis的主配置文件 SqlMapConfig.xml
    第四部:创建映射配置文件:IUserDao.xml
    环境搭建的注意事项:
    第一个:创建IUserDao.xml和IUserDao.java时名称是为了和我们之前的知识保持一致。所以Mybatis中它把持久层的操作接口名称和映射文件也叫做:Mapper,所以IUserDao和IUserMapper是一样的。
    第二个:
    在idea中创建目录的时候,它和包的是不一样的,包在创建时:com.Mybatis.dao它是三级目录,目录在创建时:com.itheima.dao是一级目录。
    环境搭建的
    第三个:mybatis的映射文件位置必须和dao接口的包结构相同
    第四个:映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
    第五个:映射配置文件的操作配置(select),id属性的取值必须是dao接口的方法名。
    当我们遵从了第三,四,五点之后,我们在开发中就无需再用dao的实现类
    MyBatis配置文件:
    在这里插入图片描述
    在这里插入图片描述
    注意:在映射配置文件中一定要指定查询的返回结果要封装到哪个实体类中,指定resultType的。
    注意:这里的namespace 和 select标签的 id 里的值,组合起来就能唯一定位到执行的方法

    入门开始:
    //1读取配置文件
    InputStream in=Resources.getResourceAsStream(Mybatis的主配置文件);
    //2创建SqlSessionFactory工厂
    SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
    SqlSessionFactory factory=builder.build(in);
    //3使用工厂生产SqlSession对象
    SqlSession session=factory.openSession();
    //4使用SqlSession创建Dao接口的代理对象
    IUserDao userDao=session.getMapper(IUserDao.class);
    //5使用代理对象执行方法
    List users=userDao.findAll();
    for(User user:users){
    System.out.println(user);
    }
    //6释放资源
    session.close();
    in.close();
    注意:在读配置陪文件时,一定要用:
    第一种:使用类加载器,但只能读取类路径下的配置文件
    第二种:使用ServletContext对象的getRealPath();
    SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
    在创建工厂时,mybatis使用了构建者模式,这里的builder就是构建者,
    构建者模式:就相当于你要修房子的时候,你自己不用修,你找来了包工队,由这个包工队修,你只需要给钱。这个包工队就相当于是构建者。
    构建者模式的优势:把对象的创建细节隐藏,使得使用者直接调用方法即可拿到对象
    SqlSessionFactory factory=builder.build(in);
    SqlSession session=factory.openSession();//这里使用了工厂模式生产了SqlSession
    工厂模式的优势:解耦(降低类之间的依赖关系)

    IuserDao userdao=session.getMapper(IUserDao.class);这里创建Dao接口实现类使用了代理模式,代理模式的优势:不修改源码的基础上对已有方法增强。
    xml方式的总结:
    第一步:读取配置文件
    第二步:创建SqlSessionFactory工厂
    第三步:创建SqlSession
    第四步:创建Dao接口的代理对象
    第五步:执行dao中的方法
    第六步:释放资源
    注意事项:
    不要忘记在映射配置中告知mybatis要封装到哪个实体类中,配置的方式:指定实体类的全限定类名。

    mybatis注解开发:
    直接在dao层的接口的抽象方法上添加注解,例如:
    public interface IUserDao{
    @Select(“select * from user”)
    List< User> findAll();

    }

    主配置文件,连接数据库的配置文件还是要有的但是要该映射标签里的resource属性,改为class属性指定被注解的dao全限定类名
    注意:把IUserDao.xml移除,在dao接口的方法上使用@Select注解,并且指定SQL语句,同时需要在SqlMapConfig.xml中的mapper配置时,使用class属性指定dao接口的全限定类名。
    例如:
    < mapperr>
    < mapper class=“com.mybatis.dao.IUserDao”
    < /mapper>
    源码分析:
    mybatis在使用代理dao 的方式实现增删改查时做了什么事呢?
    第一: 创建代理对象
    第二:在代理对象中调用selectList
    分析:
    1 以下是连接数据库的信息,有了它就可以创建Connection对象在这里插入图片描述2 有了以下信息就有了映射配置信息:
    在这里插入图片描述3 有了以下信息就有了执行的SQL语句,就可以获取PreparedStatement,同时此配置文件中还有封装的实体类的全限定类名
    在这里插入图片描述读取以上三个配置文件,用到的技术就是解析XML的技术。此处用的事dom4j解析xml技术。
    解析:
    Select方法:
    1 根据配置文件的信息创建connection对象:注册驱动 获取链接等
    2 获取预处理对象PreparedStatement,此时需要SQL语句,从mapper中获取。相当于这句:conn.preparedStatement(sql);
    3 执行查询:
    ResultSet resultSet=preparedStatement.executeQuery();
    4 遍历结果集用于封装
    List< E> list=new ArrayList();
    while(resultSet.next()){
    E element=(E)Class.forName(配置的全限定类名).newInstance();(这里从mapper配置文件中的select中的resultType属性的值中获取返回值的类信息,利用反射实例化对象)
    进行封装,把每个rs的内容添加到element中
    我们的实体类属性和表中的列名是一致的。于是我们就可以把表的列名看成是实体类的属性名称,就可以通过反射的方式来根据名称获取每个属性,并把值赋进去。
    把element加入到list中
    list.add(element);
    5 返回list
    return list;
    要想让上面的方法执行,我们需要给方法提供两个信息:
    第一个:连接信息
    第二个:映射信息
    其中映射信息包含两个部分:
    第一:执行的SQL语句
    第二:封装结果的实体类的全限定类名
    把这两个信息组合在一起定义成一个对象
    由于存在多个实体类对象,所以这里需要使用Mapper集合来存放这些对象并加以区分
    Mapper的Key存放的是,String类型的字符串,这个字符串是Mappers标签里的目标接口的全限定类型和映射文件中方法名的组合。
    而这个Mapper的值,存放的就是Mapper对象:String sql和String domainClassPath.

    4使用SqlSession创建Dao接口的代理对象
    IUserDao userDao=session.getMapper(IUserDao.class);
    //根据dao接口的字节码创建dao的代理对象
    public < T > T getMapper(Class< T > daoInterfaceClass ){
    /*类加载器:它使用的和被代理对象是相同的类加载器
    代理对象实现的接口:和被代理对象实现实现相同的接口
    如何代理:
    它就是增强的方法,我们需要自己提供。此处是一个InvocationHandler的接口,我们需要写一个该接口的实现类在实现类中调用seletLise方法。
    Proxy.newProxyInstance(类加载器,代理对象要实现的接口字节码数组,如何处理)
    }
    public void setMappers(Map< String,Mapper> mappers){
    this.mappers.putAll(mappers);//此处需要使用追加的方式。
    }

    先来看自定义MyBatis都需要写哪些类和接口:
    1 Resource 类:使用类加载器读取配置文件的类
    此类中有一个方法:根据传入的参数,获取一个字节输入流
    public static InputStream getResourceAsStream(String filePath)
    2 SqlSessionFactoryBuilder类:用于创建一个SqlSessionFactory对象
    此类中有一个返回值为SqlSessionFactory(接口)类型的方法:
    下面这个方法根据参数的字节输入流来创建一个SqlSessionFactory工厂
    public SqlSessionFactory builder(InputStream config){

    }
    3 这个SqlSessionFactory接口中有一个返回值为SqlSession的openSession()方法,这个方法用来打开一个新的SqlSession对象
    SqlSession openSession();
    4 这是一个Mybatis中和数据库交互的核心类,它里面可以创建dao接口的代理对象
    public interface SqlSession{
    这个getMapper()方法,就是根据参数创建一个代理对象
    参数为:daoInterfaceClass dao的接口字节码
    < T > T getMapper(Class daoInterfaceClass);
    }
    这个接口中还有一个close()方法用来释放资源:
    void close();
    5 这是一个mybatis的配置类:
    public class Configuration{
    private String driver;
    private String url;
    private String username;
    private String password
    private Map< String,Mapper> mappers=new HashMap< String,Mapper>();

    相应的get set方法
    注意此处的setMappers的方法一定要这样写:
     public void setMappers(Map< String,Mapper> mappers){
    	this.mappers.putALL(mappers);//此处需要使用追加的方式。
    

    }
    public void setDriver(String driver)

    }
    6 Mapper类,用于封装执行的SQL语句和结果集类型的全限定类名
    public class Mapper{
    private String queryString;//SQL语句
    private String resultType;//实体类的权限定类名
    添加相应的get set 方法

    }
    下面来解读
    解析MyBatis配置文件的工具类
    它里面有一个方法专门用来解析配置文件中的mappers标签中的 reourse 或 class的值,那么到底是resource 还是 class呢?那么在这个工具类中采用了遍历所有的mapper来判断,如果是resource那就采用xml方式解析,否则就是class则采用注解,请看以下方法:
    //取出mappers中的所有mapper标签,判断他们使用了resource还是class属性
    List< Element > mapperElements=root.selectNodes("//mappers/mapper");
    //遍历集合
    for(Element mapperElement:mapperElement){
    //判断mapperElement使用的是哪个属性
    Attribute attribute=mapperElement.attribute(“resource”);
    if(attribute!=null){
    System.out.println(“使用的是xml”);
    //表示有resource属性,用的是xml
    //取出属性的值
    String mapperpath=attribute.getValue();//获取属性的值"com/wb/do/IuserDao.xml"
    Map< String,Mapper> mappers=loadMapperConfiguration(mapperpath);
    //给configuration中的mappers赋值
    }else{
    System.out.println(“使用注解”);
    //表示没有resource属性,用的是注解
    //获取class属性的值
    String doaClassPath=mapperElement.attributeValue(“class”);
    根据daoClassPath获取封装的必要信息
    Map< String,Mapper> mappers=LoadMapperAnnotation(daoClassPath);
    //给configuration中的mapper赋值
    cfg.setMappers(mappers);

    }
    }
    //根据传入的参数,得到dao中所有的select注解标注的方法
    根据方法名称和类名,以及方法上注解value属性的值,组成Mapper的必要信息
    private static Map< String,Mapper> loadMapperAnnotation( String daoClassPath)throws Exception{
    //定义返回值对象
    Map< String,Mapper> mappers=new HashMap< String,Mapper>();
    1//得到dao接口的字节码对象
    Class daoClass=Class.forName(daoClassPath);
    2//得到dao接口中的方法数组
    Method[] methods=daoClass.getMethods();
    3//遍历Method数组
    for(Method method:methods){
    //取出每一个方法,判断是否有select注解
    boolean isAnnotated=method.isAnnotationPresent(Select.class);
    if(isAnnotated){
    //创建Mapper对象
    Mapper mapper=new Mapper();
    //取出注解的value属性值
    Select selectAnno=method.getAnnotation(Select.class);//拿到Select注解这个对象
    String queryString=selectAnno.value();//取出这个Select注解的value值
    mapper.setQueryString(queryString);
    //获取当前方法的返回值,还要求必须带有泛型信息
    Type type=method.getGenericReturnType();//List< User>
    //判断type是不是参数化的类型
    if(type instanceof ParameterizedType){
    //强转
    ParameterizedType ptype=(ParameterizedType)type;
    //得到参数化类型中的实际类型参数
    Type[] types=ptype.getActualTypeArguments();
    //取出第一个
    Class domainClass=(Class)type[0];
    //获取domainClass的类名
    String resultType=domainClass.getName();
    //给Mapper赋值
    mapper.setResultType(resultType);
    }
    //组装key的信息
    //获取方法的名称
    String methodName=method.getName();
    String className=method.getDeclaringClass().getName();//获取该方法发所属于的类的类名
    String key=className+"."+methodName;
    //给maps赋值
    mappers.put(key,mapper);
    }
    }

    return mappers
    }
    private static Map< String,Mapper> loadMapperAnnotation( String daoClassPath)throws Exception{

    }
    方法:根据传入的参数,解析xml,并且封装到Map中
    @Param:mapperPath 映射配置文件的位置
    @return:map中包含了获取的唯一标识(key是由dao的全限定类名和方法名组成)
    以及执行所需的必要信息(value是一个Mapper对象,里面存放的是执行的SQL语句和要封装的实体类全限定类名)
    private static Map< String,Mapper> loadMapperConfiguration(String,mapperPath) {
    InputStream in=null;
    try{
    //定义返回值对象
    Map< String,Mapper> mappers=new HashMap< String,Mapper>();
    //根据路径路径获取字节输入流
    in=Resources.getResourceAsStream(mapperPaht);
    //根据字节输入流获取Document对象
    SAXReader reader=new SAXReader();
    Document document=reader.read(in);
    //获取根节点
    Element root=document.getRootElement();
    //根据根节点的namespace属性取值
    String namespace=root.attributeValue(“namespace”);//是组成map中key的部分
    //获取所有的select节点
    List< Element> selectElements=root.selectNode("//select");
    //遍历select节点集合
    for(Element selectElement:selectElements){
    //取出id属性的值 组成map中key的部分
    String id=selectElement.attributeValue(“id”);
    //取出resultType属性的值 组成map中value的部分
    String resultType=selectElement.attributeValue(“resultType”);
    //取出文本内容 组成map中value的部分
    String queryString=selectElement.getText();
    //创建Value
    Mapper mapper=new Mapper();
    mapper.setQueryString(queryString);Sql语句
    mapper.setResultType(resultType);//返回值类型的全限定类名
    //把key和value存入mappers中
    mappers.put(key,mapper);
    }
    return mappers;
    }
    }

    下面来看SqlSessionBuilder类中的方法:
    public SqlSessionFactory build(InputStream config){
    Configuration cfg=XMLConfigBuilder.LoadConfiguration(config);
    }

    创建SqlSessionFactory接口的实现类:
    public class DefaultSqlSessionFactory implements SqlSessionFactory{
    private Configuration cfg;
    public DefaultSqlSessionFactory(Configuration cfg){
    this.cfg=cfg;
    }
    //用于创建一个新的操作数据库对象
    public SqlSession openSession(){
    return new DefaultSqlSession(cfg);
    }

    }
    创建一个SqlSession接口的实现类DefaultSqlSession
    public class DefaultSqlSession implements SqlSession{
    private Configuration cfg;
    private Connection connection;
    public DefaultSqlSession(Configuration cfg){
    this.cfg=cfg;
    connection=DataSourceUtil.getConnection(cfg);
    }
    //用于创建代理对象的方法
    public < T > getMapper(Class< T > daoInterfaceClass){
    Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(),new Class[]{daoInterfaceClass},new MapperProxy(cfg.getMappers(),connection))

    }
    //用于释放资源的方法
    public void close(){
    connection.close();
    }

    }
    创建一个实现InvocationHandler接口的类,用来具体实现代理对象要增强的方法
    public class MapperProxy implements InvocationHandler{
    //这个map的key是全限定类名+方法名
    private Map< String,Mapper> mapper;
    private Connection conn;
    public MapperProxy(Map< String,Mapper> mappers,Connection conn){
    this.mappers=mappers;
    this.conn=conn;
    }
    //用于对方法进行增强的,我们的增强其实就是调用selectList方法。
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
    //获取方法名
    String methodName=method.getName();
    //获取方法所在类的名称
    String className=method.getDeclaringClass().getName();
    //组合key
    String key=className+"."+methodName;
    //获取mappers中的Mapper对象
    Mapper mapper=mapper.get(key);
    //判断是否有mapper
    if(mapper==null){
    throw new IllegalArgumentException(“传入的参数有误”);
    }
    //使用工具类执行查询所有
    return new Executor().selectList(mapper,conn);
    }
    }
    由于以上类中需要用到DataSourceUtil,所以我们在下面创建一个DataSourceUtil的类,用于创建数据源的工具类
    public class DataSourceUtil{
    //用于获取一个连接
    public static Connection getConnection(Configuration cfg){
    try{
    Class.forName(cfg.getDriver());
    return DriverManager.getConnection(cfg.getUrl(),cfg.getUsername(),cfg.getPassword());
    }
    }
    }

    基于注解方式的解析
    1 定义一个查询的注解 @Interface Select
    @Retention(RetentionPolicy.RUNTIME);//该注解的生命周期
    @Target(ElementType.METHOD);//该注解的作用域
    public @interface Select{
    //配置SQL语句的属性
    String value();
    }
    MyBatis的增删改查实例:
    增加数据到数据库中:
    1在dao接口中添加增加数据的抽象方法
    2在相应的mappers映射配置文件中添加配置信息例如:
    //保存用户
    < insert id="saveUser’’ parameterType="com.wb.model.User’’>注意:这里的parameterType里的值是SQL语句中values里面传入的参数字段所属的类的全类名
    insert into user(username,address,sex,birthday)values(#(username),#(address),#(sex),#(birthday));
    < /insert>
    注意在测试类中测试保存方法时,要手动提交事务,才能成功将数据插入到数据库中
    SqlSession.commit();
    2更新操作:
    1首先在dao接口中添加相应的抽象方法
    2 配置更新的SQL
    < update id=“updateUser” parameterType=“com.wb.model.User”>
    update user set username=#{ username},address=#{ address},sex=#{ sex},birthday=#{ birthday} where id=#{ id}
    < /update>
    3 根据id删除用户
    1 添加抽象方法: void deleteUser(Integer userId);
    2 配SQL映射文件
    < delete id="deleteUser’’ parameterType=“java.lang.Integer”>
    delete from user where id=#{id} 注意当参数类型是一个基本类型或者基本类型的包装类的类型时,且当这个参数只有一个时,参数可以随便起名,相当于一个占位符。
    < /delete>
    模糊查询:
    首先在dao接口中定义 List< User> findByName( String username);
    2 在mapper映射文件中定义sql:
    < select parameterType="String’’ resultType=“com.wb.model.User”>
    select * from user where username like=#{name} 这种方式采用 PreparedStatement预处理的方式
    另一种写法:
    select * from user where username=like ‘%${value}%’ 注意这种方式这里必须写value,不能随便写。这种方式采用statement的拼接字符创的方式
    < /select>
    注意这里的sql语句中并没有提供%,所以在测试方法中需要我们自己提供%到参数中
    如果是在自增长类型的表中插入数据,当想要拿到这个id的值时,我们可以使用这句SQL:select last_insert_id();
    MyBatis
    OGNL表达式:
    Object Graphic Navigation Language(对象 图 导航 语言)
    它是通过对象的取值方法来获取数据,在写法上把get给省略了。
    比如:我们以前在获取用户的名称:
    类中的写法:user.getUserName
    OGNL表达式写法:user.userName
    Mybatis之所以可以直接使用userName,是因为我们在parameterType中已经指明了所属类的名称。
    假如现在有这样一个需求:
    在查询到的数据库中,先把数据库中的数据封装到一个实体类中,这样的实体类有很多,现在我们需要把这些个实体类,也用一个类给他们封装起来,那么久需要在定义一个类把这些返回的类作为保存实体类的类的成员变量。那么在mapper配置文件中我们的参数就不能是普通的那样,这里就是一OGNL表达式的应用
    < Select id=“findByName” parameterType="com.wb.dao.QueryVo’’ resultType=“com.wb.User”>
    select * from user where username= like #{user.username}
    </ select>
    这种由多个对象组成查询条件,来实现查询在实际的开发中经常用到。
    Mybatis的结果类型封装。
    注意:如果在封装结果集到一个对象中,出现了数据库中的字段和JAVABean中的属性名不一致的情况我们有两种解决方案:
    1 给数据库中的字段起别名,别名和JAVABean中的属性要一致
    2 配置 查询结果的列名和实体类的属性名的对应关系
    < resultMap id="userMap’’ type=“com.wb.model.user”>
    //主键字段的对应

    //非主键字段的对应
    < result>< /result>
    </ result>
    < !–配置properties
    可以在标签内部连接数据库的信息,也可以通过引用外部配置文件信息
    resource 属性:常用的
    用于指定配置文件的位置,是按照相关类路径的写法来写,并且必须存在于类路径下。
    url属性:
    是要求按照url的写法来写地址
    URL:Uniform Resource Locator 统一资源定位符,它可以唯一标识一个资源的位置
    它的写法: http://localhost:8080/mybatisserver/demoIservlet
    URI:统一资源定位符,它是在应用中可以唯一定位一个资源的。
    使用typeAliases配置别名,它只能配置domain中类的别名
    例如:
    < typeAlias>
    < typeAlias type=“com.wb.do.User” alias=“user”></ typeAlias> 配置了别名不区分大小写。
    < /typeAlias>
    用于指定要配置别名的包,当指定之后,该包下的实体类都会注册别名,并且类名就是别名,不再区分大小写。
    < package name=“com.wb.dao”>< /package>

    < mappers>

    < package> 标签是用于指定dao接口所在的包,当指定了之后就不需要在写mapper以及resource或者class了。
    < package name=“com.wb.do”></ package>
    </ mappers>

    Mybatis连接池: 连接池就是用于存储连接的一个容器,容器其实就是一个集合对象,该集合必须是线程安全的,不能两个线程拿到同一个连接,该集合还必须实现队列的特性:先进先出。

    mybatis连接池提供了3种方式的配置:
    配置的位置:
    主配置文件SqlMapConfig.xml中的dataSource标签,type属性就是表示采用何种连接池方式。
    type属性的取值:
    POOLED 采用传统的javax.sql.DataSource规范中的连接池,mybatis中有针对规范的实现
    UNPOOLEN:采用传统的获取连接的方式,虽然也实现Javax.sql.DataSource接口,但是并没有使用池的思想。
    JNDI 采用服务器提供的JNDI技术实现,来获取DataSource对象,不同的服务器拿到的DataSource是不一样的。注意:如果不是web或者maven的war工程,是不能使用的。tomcat服务器,采用连接池就是dbcp连接池。

    Mabatis中的事物
    什么是事物
    事物的四大特性ACID
    不考虑隔离性会产生的3个问题
    解决办法:四种隔离级别。
    设置Mybatis自动提交事物的方法:
    openSession(boolean autoCommit);
    Mybatis的动态SQL:
    需求:根据查询的条件,查询条件有可能是用用户名,有可能是性别,也有可能死地址,还有可能是都有。
    那么在写配置时的时候我们就需要这样写:
    < select id=“findUserByCondition” resultMap="userMap’’ parameterType=“user”>
    select * from user where 1=1
    < if test=“username !=null”>
    and username=#{username}
    < /if>
    < if test=“userSex != null”>
    and sex=#{userSex}
    < /if>
    </ select> } 等价于下面代码:
    select * from user
    < where>

    and username=#{userName}
    </ if>
    < if test=“userSex !=null”>
    and sex=#{userSex}

                < /if>
    
        </where>
    

    带in的子查询:
    select * from user
    < where>
    < if test=“ids !=null and ids.size()>0”>
    < foreach collection=“ids” open=“and id in (“close=”)” item=“uid separator=”,">
    #{uid}
    < /foreach>
    < /if>
    < where>
    mabatis中的多表查询:
    实例:用户和账户
    一个用户可以有多个账户
    一个账户只能属于一个用户(多个账户也可以属于同一个用户)
    步骤:
    1 建立两张表:用户表,账户表
    让用户表和账户表之间具备一对多的关系:需要使用外键在账户表中添加
    2 建立两个实体类::用户实体类和账户实体类
    让用户和账户的实体类之间能体现出一对多的关系
    3 建立两个配置文件:
    用户配置文件
    账户配置文件
    4 实现配置:
    当我们查询用户时,可以同时得到用户下所包含的所有账户信息
    当我们查询账户时,可以同时得到账户的所属用户信息。
    mybatis中完成一对一操作-建立实体类关系的方式
    < resultMap id="userMap’’ type=“com.wb.model.user”>
    //主键字段的对应

    //非主键字段的对应
    < result>< /result>
    </ result>
    < 定义封装account和user的resultMap>
    < resultMap id=“accountUserMap” type=“account”>
    < id property=“id” colum=“uid”>< /id>
    < result property=“uid” column=“uid”>< result>
    < result property=“money” column=“money”>< /result>
    < 一对一的关系映射,配置封装user的内容>
    < association property=“user” column=“uid” javaType="com.wb.dao.user>
    < id property=“id” column=“id”>< /id>
    < result column=“username” property=“username”>< /result>
    < result column=“address” property=“address”>< /result>
    < result column=“sex” property=“sex”>< /result>
    < result column=“birthday” property="birthday>< /result>
    < /association>
    < /resultMap>
    在查询语句中需要这么写:
    < select id=“findAll” resultMap=“accountUserMap” >
    select u.*,a.id as aid,a.uid,a.money from account a,user u where u.id=a.uid;
    < /select>
    一对多查询操作:
    需求:查询所有用户,同时获取到用户下所有账户的信息
    在IuserDao接口中定义方法:List< User> findALL();
    同时要在实体类中加上:
    一对多关系映射,主表实体应该包含从表实体的集合引用。
    private List< Account> accounts:
    在IuserDaos.xml中:
    定义User的resultMap
    < resultMap id=“userAccountMap” type=“user”>
    < id property=“id” column=“id”>< /id>
    < result property=“username” column=“username”>< /result>
    < result property=“address” column=“address”>< /result>
    < result property=“sex” column=“sex”>< /result>
    < result property=“birthday” column=“birthday”>< /result>
    < !–配置user对象中accounts集合的映射-- >
    < collection property=“accounts” ofType=“account”>(这个ofType表示集合中元素的类型。)
    < id column=“id” property=“id”>< /id>
    < result column=“uid” property=“uid”>< /result>
    < result column=“money” property=“money”> < /result>
    < /collections>
    < /resultMap>

    < – 查询所有–>
    < select id=“findAll” resultMap=“userAccountMap”>
    select * from user u left outer join account a on u.id=a.uid
    < /select>

    MyBatis维护多对多
    实例:用户和角色
    一个用户可以有多个角色,一个角色可以赋予多个用户
    1 建立两张表:用户表,角色表
    让用户表和角色表具有多对多的关系,需要使用中间表,中间表中包含各自的主键,在中间表中是外键。
    2 建立两个实体类:用户实体类和角色实体类
    让用户和角色的实体类能体现出来多对多的关系,各自包含对方一个集合引用。
    3 建立两个配置文件
    用户配置文件 角色的配置文件
    4 实现配置:
    当我们查询用户时,可以同时得到用户所包含的角色信息
    当我们查询时,可以同时得到角色的所属用户信息。
    1 在两张表的实体类中分别定义一个多对多的关系映射,就是分别在每个实体表中定义另一张表的集合对象引用。
    例如:
    public class Role implements Serializable{

    private List< Users> users;
    //生成相应的get和set方法.

    }
    public class Users implements Serializable{

    private List< Role > role;
    //生成相应的get 和 set方法
    }

    配置IRoleDao.xml文件:
    mapper namespace=“com.wb.dao.IRoleDao”
    //定义role表的ResultMap
    < resultMap id=“roleMap” type=“role”>
    < id property=“roleId” column=“id”></ id>
    < result property=“roleName” column=“role_name”>< /result>
    < result property=“roleDesc” column=“role_desc”>< /result>
    < collection proper=“users” ofType=“com.wb.dao.user”>
    < id column=“id” property=“id”>< /id>
    < result column=“username” property=“username”>< /result>
    < result column=“address” property=“address”>< /result>
    </ collection>
    < /resultMap>
    //查询所有
    < select id=“findALL” resultMap=“roleMap”>
    select u.*,r.id as rid,r.role_name,r.role_desc from role r
    left outer join user_role ur on r.id=ur.rid
    left outer join user u on u.id =ur.uid
    < /select>
    JNDI数据源:
    JNDI数据的存放格式就好比windows系统系下的注册表格式:
    在这里插入图片描述
    1 Mybatis 中的延迟加载
    思考:在一对多中,当我们有一个用户,它有100个账户?
    在查询用户的时候,我们不需要把这个用户的账户查出来因为会造成内存耗费过大。应该是,什么时候使用,什么时候查询出来。
    在查询账户的时候,要不要把关联的用户查出来?
    在查询账户时,账户的所属用户信息应该是随着账户查询时一起查询出来。
    什么是延迟加载:
    在真正使用数据时才发起查询,不用的时候不查询。按需加载(懒加载)
    什么是立即加载
    不管用不用,只要一调用方法,马上发起查询
    在对应的四种关系中:一对多, 多对一,一对一,多对多
    一对多,多对多:通常情况下我们都是采用延迟加载: 因为比如说有这么一个需求,当用户查询他的基本信息,这是加入用户表,对应多个角色表,就是我们所说的一对多的关系,那么这个时候如果,才用立即查询,由于用户的角色有很多,那么就会造成内存的浪费,所以我们采用延迟加载,有需要的时候在加载。

    多对一,一对一:通常情况下我们都是采用立即加载,
    

    实例:延迟加载:
    <mapper namespace=“com.wb.do.IAccountDao”
    < !–定义封装account和user的resultMap---->
    < resultMap id=“accountUserMap” type=“account” >
    < id property=“id " column=” id " >< /id>
    < result property=" uid" column=" uid"> < /result>
    < result property=" money" column=" money"> < /result>
    < !-- 一对一的关系映射,配置封装user的内容,select属性指定的内容,查询用户的唯一标识,因为这时候,是延迟加载,就不能之使用 < association> 这个标签来立即封装了.,就需要在association这个标签上加上属性select=“要封装的表对应的mapper 的查询方法名”—>
    < assocation property=“user” column=“uid” javaType=“user” select="com.wb.dao.IuserDao.findById></ association>

    因为是延迟查询所以我们不用封装Map,只需要下下方封装user就可以了
    < select id=“findById” parameterType="INT’’ resultType=“user”>
    select * from user where id=#{uid}
    < select>
    < /mapper>
    重要的一步,需要在mybatis的主配置文件中开启延迟查询:
    在< configuration> 的标签下配置:
    < settings>
    < setting name=“lazyLoadingEnabled” value=“true” /> < !-- 当开启此配置后延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。–>
    < setting name=“aggressiveLazyLoading” value=“false”></ setting> <! – 当开启时,任何方法的调用都会加载该对象的所有属性。 否则,每个属性会按需加载(参考 lazyLoadTriggerMethods)。 -->
    </ settings>

    mybatis一对多实现延迟加载:
    首先需要在IusereMapper.xml配置文件中需要这样配置:
    < !–定义User的resultMap–>
    < resultMap id=“userAccountMap” type=“user”>
    < id property=“id” column=“id”>< /id>
    < result property=“username” column=“username”>< /result>


    <!-- 配置user对象中account集合的映射— >
    < collection property=“accounts" ofType=“account” select=“com.wb.dao.IAccountDao.findAccountByUid” column=“id”>
    < /resultMap>
    < !–查询所有>
    < select id=“findAll” resultMap=“userAccountMap”>
    这时需要在IRoleDao的接口中添加方法:
    List< Role> findAccountByUid(Integer uid);//根据用户id查询账户信息.

    之后需要在IRoleDao.xml中添加配置:
    < resultMap id=“RoleRuserMap” type=“com.wb.Entity.Role”>
    < id>< /id>
    < result>< /result>

    < association property=“user” column=“uid” javaType=“com.wb.Entity.user” select=“com.wb.dao.IuserDao.findAllUserByID”>< /association>
    < resultMap>
    < !–根据用户id查询账户列表 -->
    < select id=“findAccountByUid” resultType=“account”>
    select * from account
    < /select>

    MyBatis中的缓存
    什么是缓存
    存在于内存中的临时数据。
    为什么使用缓存
    减少和数据库的交互次数,提高执行效率。
    什么样的数据能用缓存,什么样的数据不能使用
    适用于缓存:
    经常查询并且不经常改变的
    数据的正确与否对最终结果影响不大的
    不适用于缓存:
    经常改变的数据
    数据的正确与否对最终结果影响很大的
    例如:商品的库存,银行的汇率,股市的牌价。
    mybatis中的一级缓存:
    一级缓存:
    它指的是,当我们执行一个查询语句时,查询的结果会同时存入到SqlSession为我们提供一块区域中。
    该区域的结构是一个Map。当我们再次查询同样的数据,mybatis会先去sqlsession中查询是否有,有的话就直接拿出来用。
    当SqlSession对象消失时,mybatis的一级缓存也就消失了。
    sqlSession.clearCache();//此方法也可以清空缓存.
    一级缓存是SqlSession范围的缓存,当调用SqlSession的修改,添加,删除,commit(),close()等方法时,就会清空一级缓存.
    Mybatis的二级缓存:它指的是Mybatis中SqlSessionFactory对象的缓存,由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
    二级缓存中存放的是数据而不是对象。
    二级缓存的使用步骤:
    第一步:让Mybatis框架支持二级缓存(在SqlMapConfig.xml)中配置
    < settings>
    < setting name=“cacheEnabled” value=“true” />
    < /settings>
    第二步:让当前的映射文件支持二级缓存(在IUserDao.xml中配置)
    开启user支持二级缓存
    < cache/>
    第三步:让当前的操作支持二级缓存(在select标签中配置)
    < select id=“findById” parameterType=“INT” resultType=“user” useCache=“true”>
    MyBatis中的注解开发:
    首先说明:
    在MyBatis中针对,CRUD(增删该查)一共有四个注解
    1 @Select 2 Insert 3 Update 4 Delete
    例如在IUserDao中有这么一个需求,要查询用户的所有信息那么:
    @Select("select * from user’’) 这里的value属性写查询语句,当只有一个的时候,就可以不用写value.
    @Select(“select * from user”)
    List< User> findAll();
    MyBatis中要么全用注解开发,要么全用xml方式开发,不能混合使用,会报错。
    注意:同时需要javaBean中的实体类实现序列化接口。

    在这里插入图片描述

    MyBatis中的多表:
    首先了解一下:MyBatis中的一个Results注解,这个注解就是将mysql中的列和实体类的属性一一映射的配置:
    @Select(“select * from user”)
    @Results(id=“userMap” value={
    @Result(id=true,column=“id”,property=“userId”),这个代表主键,当加上id=true代表这个属性是主键。
    @Result(column=“username”,property=“userName”),
    @Result(column=“address”,property=“userAddress”),
    @Result(column=“sex”,property=“userSex”),
    @Result(column=“birthday”,property=“birthday”),
    })
    List< User> findAll();
    以上的id=userMap 唯一定位了那个Result,实现了可以复用。

    一对多的注解配置:
    例如:
    public interface IAccountDao{
    /*
    查询所有账户,并且获取每个账户所属的用户信息
    */
    @Select(“select * from account”)
    @Results(id=“accountMap”,value={
    @Result(id=true,column=“id”,property=“id”),
    @Result(column=“uid”,property=“uid”),
    @Result(column=“money”,property=“money”),
    @Result(property=“user”,column=“uid”,one=@One(select=“com.wb.do.IuserDao.finById”,fetchType=FetchType.EAGER))
    })
    List< Account > findAll();
    }

    一对多的多表查询:
    @Select(“select * from user”)
    @Results(id=“userMap”,value={
    @Result(id=true,column=“id”,property=“userId”),
    @Result(column=“username”,property=“userName”),
    @Result(column=“address”,property=“userAddress”),
    @Restult(column=“sex”,propety=“userSex”),
    @Result(property=“accounts”,column=“id”,many=@Many(select=“com.wb.do.IAccountDao.findAccountByUid”,fetchType=FetchType.LAZY))

    })
    在MyBatis中在一对多查询多的时候通常采用延迟加载,在一对一查询一通常情况下采用立即加载。

    MyBatis缓存的注解配置。
    在全局配置文件中setting上 cacheEnable=true;
    在dao的接口上注解上:@CacheNamespace(blocking=true)
    public interface IUserDao{


    }

    在这里插入图片描述

    展开全文
  • 抗震支架价格对比

    2020-07-06 17:28:22
    抗震支架价格对比目前在网上很难找到详细的。每个品牌商、每个厂家、每个供货商的价格都不一样,一般也很少有公司会直接把价格放在网上,除非你有非常强的购买需求才会把价格体系发给你。 那我们怎样才能把抗震支架...
    抗震支架价格对比目前在网上很难找到详细的。每个品牌商、每个厂家、每个供货商的价格都不一样,一般也很少有公司会直接把价格放在网上,除非你有非常强的购买需求才会把价格体系发给你。
     那我们怎样才能把抗震支架的价格对比出来呢?首先,多找几家抗震支架生产商,厂家,公司等都可以,了解他们的价格后再进行一一对比。当然这个相对比较麻烦但确实最实际的做法。
    名气比较大的品牌价格会比一般的品牌价格高出不止一倍,当然质量也是毋庸置疑的,不过现在抗震支架的质量整体都有了很大的提升一些名气不是特别大,但是有野心的公司生产的抗震支架质量都类同于品牌质量,价格却低很多。发展中的公司在服务上肯定会做到极致来打响自己的品牌效益。所以,价格有了、质量有了、服务有了,其他都不是问题。如果没有硬性的品牌要求,可以寻找这样的公司合作。推荐杭州企星贸易有限公司,浙江赛诚科技旗下抗震支架配件材料子公司。
    杭州企星贸易坐落于环境优美的省会城市——杭州,是一家专注于为建筑工程做配套产品及服务的企业。公司拥有团结奋进的管理团队和经验丰富的施工团队,秉承“质量为本”的企业宗旨,为客户提供高品质的建筑配套产品及设计、施工、安装一条龙服务。公司坚持“信誉第一”的服务宗旨,努力打造优良的企业形象。企星服务客户,连通厂家实现各方“共创双赢”。公司主营:抗震支架、管道支架、支架配件等。产品种类齐全,价格实在。同品质敢比价格、同价格敢比服务,实实在在的利润到你手。
    抗震支架槽钢价格(同品质):企星23元/米    优力可50(折后价)元/米。
    

    杭州企星贸易合作电话:18167135927,微信同号
    在这里插入图片描述

    展开全文
  • 但是现在不用了,我们有了一个包工队:builder,我们只需要把钱:in 给它,它就把把工厂:factory 建好 三、工厂模式 //3、使用工厂生产SqlSession对象 SqlSession session = factory.openSession(); 生产SqlSession...
  • PHP的常见语法 PHP代码执行方式: 在服务器端执行,然后返回给用户结果。如果直接使用浏览器打开,就会解析为文本。 意思是说,需要浏览器通过 http请求,才能够执行php页面。 这里只列举常用的PHP语法,...&...
  • 所以最简单的就是找一个包工队,所以SqlSessionFactoryBuilder就是那个包工队,in就是钱 ) 优点:把对象的创建细节隐藏,使使用者直接调用方法即可拿到对象。屏蔽了很多繁琐的操作 SqlSession 生产...
  • (2)构建者:就像盖房子,找的包工队。 (3)优点:把对象的创建细节隐藏,让使用者直接调用方法即可拿到对象;减少繁琐的操作。 工厂模式: (1)生产SQLSession使用了工厂模式。 (2)优点:使用工厂去生产一个...
  • } //创建工厂 //创建工厂时,mybatis使用了构建者模式,即找包工队盖房子,而不是自己亲自处理一系列问题 SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactory factory = ...
  • 这时我们找一个包工团队,只要给钱,就能办好。代码里面的SqlSessionFactoryBuilder就是这样的团队。里面所有繁琐的事都不用管了。 为什么要使用工厂模式创建Session对象呢?直接用new不行吗? 比如我们刚开始new了1...
  • //创建工厂 //创建工厂时,mybatis使用了构建者模式,即找包工队盖房子,而不是自己亲自处理一系列问题 SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactory factory = builder...
  • //创建工厂 //创建工厂时,mybatis使用了构建者模式,即找包工队盖房子,而不是自己亲自处理一系列问题 SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactory factory = builder...
  • 像我们自己盖厂房一样,不是事事亲为,我们找个包工队,告诉需求,给钱即可: SqlSessionFactoryBuilder类似于包工队; in类似于我们给的钱; 3)创建SqlSession对象 使用了工厂模式,降低了类之间的依赖关系 4)...
  • 2020=1024+996,程序员本命年,职场很艰辛

    万次阅读 多人点赞 2020-01-03 00:20:28
    一个打杂的外包工,一般都是10k-20k 深圳招.Net的外包数来数去就那几家的(中软国际、软通动力、文思海辉、博彦科技、武汉佰钧成、塔塔集团、印孚瑟斯…),以前经常打电话让我去面试,后来再没有打过了,当时...
  • 创建工厂Mybatis使用了构建者模式(类似于找个包工队帮你装修),builder就是构建者 session的创建使用了工厂模式(要什么给什么),优势在于解耦,降低类之间的依赖关系 getMapper中使用了代理模式,优势在于不修改...
  • 老二呢,听说邻村有一个包工队,可以帮人盖房子。于是他去请包工队为自己建房子。    老三想盖个大房子,但又没有那么多钱,于是找了镇上的专家泰坦咨询。 泰坦帮助他明确了自己的需求,制定了一份长期、细致的...
  • MyBaits基础部分总结

    2020-11-18 22:45:10
    获取SqlSessionFactoryBuilder对象(作为构建者(包工队)) SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); //3.让构建者来创建SqlSessionFactory(会话工厂) SqlSessionFactory factory = ...
  • SqlSessionFactoryBuilder就是包工队,只需要给钱 创建一个包工队 SqlSessionFactoryBuilder builder =new SqlSessionFactoryBuilder(); 给包工队建造工厂的要求 SqlSessionFactory factory = builder.build(in)...
  • 装修日记--预算篇

    千次阅读 2012-05-29 21:21:50
    7、水路改造工程最好是PPR水管厂家来做,价格便宜产品质量和施工质量都有保证,PPR水管最好的是6分的热水管,一厨一卫,厂家来做包工包料不超过1K;一厨两卫不超过2K。电路改造工程要把所用材料信息详细列举一些,越...
  • 200条家装小常识

    千次阅读 2010-03-23 14:38:00
    59、豪华自动晾衣的价格水分太大,比较后发现一些不出名的牌子在结构设计上反而胜过了一线品牌,价格却低很多。   60、可以考虑采用安在地面的金属插座,这种插座很贵100多,但是挺方便,平时与地面齐平...
  • 200条装修小常识

    千次阅读 2010-01-04 10:48:00
    59、豪华自动晾衣的价格水分太大,比较后发现一些不出名的牌子在结构设计上反而胜过了一线品牌,价格却低很多。   60、可以考虑采用安在地面的金属插座,这种插座很贵100多,但是挺方便,平时与地面齐平,脚...
  • 59、豪华自动晾衣的价格水分太大,比较后发现一些不出名的牌子在结构设计上反而胜过了一线品牌,价格却低很多。   60、可以考虑采用安在地面的金属插座,这种插座很贵100多,但是挺方便,平时与地面齐平,脚...
  • 、豪华自动晾衣的价格水分太大,比较后发现一些不出名的牌子在结构设计上反而胜过了一线品牌,价格却低很多。 60 、可以考虑采用安在地面的金属插座,这种插座很贵 100 多,但是挺方便,平时与地面齐平,脚一踩...
  • 59、豪华自动晾衣的价格水分太大,比较后发现一些不出名的牌子在结构设计上反而胜过了一线品牌,价格却低很多。   60、可以考虑采用安在地面的金属插座,这种插座很贵100多,但是挺方便,平时与地面齐平,脚...
  • 装修小常识(200条)

    千次阅读 2009-10-20 11:56:00
    59、豪华自动晾衣的价格水分太大,比较后发现一些不出名的牌子在结构设计上反而胜过了一线品牌,价格却低很多。   60、可以考虑采用安在地面的金属插座,这种插座很贵100多,但是挺方便,平时与地面齐平,脚...
  • 在厨房墙壁上悬挂调味是很好的选择即漂亮有实用,不过要把吊柜下面的电源插座下移,否则调味会挡住插座,给今后的厨房小家电的使用带来麻烦。插座下沿的高度=地砖高度(含水泥沙浆大约5厘米)+地柜高度(80-85...
  • mybatis01_入门案例

    2020-04-21 00:34:23
    构建者模式简单的说就是我现在想要建造一个工厂,自己建造伤身又费力,所以找一个包工队,提供图纸,我直接收找包工头建造好的工厂。 优势:把对象的创建过程隐藏,使使用者直接调用方法即可拿到对象。 3.生产...
  • 都会导致项目改变位置的时候读不到配置文件 2、创建factory使用了构建者模式,builder就是构建者,创建工厂类比交给包工队来完成,in好比是钱,给钱包工队就开始干活。使得繁琐的细节都隐藏起来了。将对象的创建细节...
  • J公司是一家经营建筑工程的私营公司,公司成立初期只有几个人,承接项目之后,就找一些包工队来干活。经过几年的经营,J公司逐渐成长壮大,员工由最初的几个人发展到几十个人。  企业...
  • 一、概述 在创建servlet时会覆盖service()方法,或doGet()/doPost(),这些方法都有两个参数,一个为代表请求的request和代表响应的response。service方法中的response的类型是ServletResponse,而...三、通过抓包工

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 224
精华内容 89
关键字:

包工架