Week11手写笔记

本周内容

1.git

1.git的定义?
	分布式版本控制系统,是一个开源的分布式版本控制系统,可以有效、高速地处理从很小到非常大的项目版本管理.也是Linus Torvalds为了帮助管理Linux内核开发而开发的一个开放源码的版本控制软件。
svn的定义:版本控制工具-->集中式版本控制工具

1.1 git的使用流程

在linuxx上清空命令:clear
工作区:自己磁盘上的地址文件夹
暂存区:将代码添加暂存区(stage存储区域)
提交本地仓库:将暂存区中的内容,提交到本地仓库(存放项目,相关代码)--->push--->远程仓库
工作区-->pull(拉取)-->直接远程仓库的内容
git的使用方式(1):命令行的方式(实际开发中,推荐使用)
	第一步:初始化本地库:git init-->文件夹中产生.git文件夹
	第二步--->git add-->将自己的工作区的java文件放入暂存区
	第三步:git commit -m "文字说明"--->提交本地库
	第四步: get status 文件名---->查看git状态(绿颜色表示已经在暂存区,但是还没有提交到本地仓库中)
	第五步:将本地仓库文件推送到远程仓库
		1)在gitee上注册自己的码云账号
		2)创建一个远程仓库,得到Http的远程.设置公共性
		3)在git命令行中给Htttps地址设置别名  
			git remote add origin(别名) 远程仓库地址
		4)get push origin 分支的名称(默认主分支master)
		5)输入你自己的码云的账号和密码
			如果之前登录过别人的码云账号,需要在控制面板将windows的凭据管理器清空掉

1.2 第一次使用git命令行的时候:使用签名信息,否则无法连接到远程仓库

签名信息:系统级别(建议)/项目级别
等会需要将当前本地仓库的文件-->推送到远程仓库上,设置全局签名信息
	git config --global user.name:用户名-->英文名
	git config --global user.email:邮箱
设置了签名信息后,可以在C:\user\gitconfig中查看

1.3 git的一些其他命令

git log :查看当前日志

git branch 分支名称:创建本地仓库分支

git checkout 分支名称 —>切换分支

git pull 远程仓库别名 分支名称: 从远程仓库拉项目

git clone 远程仓库地址–>从远程仓库上复制克隆项目

git.clone:复制克隆 和 git.pull :拉(下载)的区别

前者:只是将远程仓库的项目复制下来,并不存在自己的本地库,所以没有办法去使用git的命令行方式 git add,git commit,git push--必须要能够进行命令方式---必须初始化本地库 git init ,换句话说也就是只是复制了项目,但是没有初始化本地仓库
 
后者:是直接就是在当前本地库中将远程仓库中的更新代码拉取到自己本地库中!
实质区别:克隆只是将项目复制到了文件夹,并没有存储到本地仓库中,而pull则是直接下载到了本地仓库中,完成修改后可以直接push到远程仓库中

1.4 linux的控制台命令

ls:查看文件夹下的文件  
cat 文件名称.后缀 :查看文件   
cd 文件夹  进入指定目录   
ll:罗列当前文件夹下的所有文件以及文件夹的详细信息类似于windows中的dir命令

2.后期做项目(团队项目:5人一组):githup/gitee代码

团队内部协作开发的流程由5人一起完成
	组长进行创建项目,发布在gitee(马云)上,组员再远程仓库中拉下来完成自己的模块

3.mybatis的入门

MyBatis 是一款优秀的持久层框架(ORM映射框架),前身是ibatis,MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO为数据库中的记录。
也就是xml配置文件可以将数据库中表的字段和pojo的属性一一映射,也可以说代替了jdbc的操作
什么是框架?
	是一个半成品的东西(一堆核心的配置文件和一堆通用的代码组成)

3.1 mybatis的使用

1)在mawen项目下导入mybatis的jar包
2)mybatis的xml配置方式

3.1.1 第一步:导包

 <!--mysql驱动jar包-->        
     <dependency>            
     <groupId>mysql</groupId>            
     <artifactId>mysql-connector-java</artifactId>            
     <version>8.0.23</version>        
     </dependency>        
     <!--单元测试的jar包-->        
     <dependency>            
     <groupId>junit</groupId>            
     <artifactId>junit</artifactId>            
     <version>4.13.1</version>            
     <scope>test</scope>        
     </dependency>        
     <!--导入mybatis的依赖-->        
     <dependency>            
     <groupId>org.mybatis</groupId>            
     <artifactId>mybatis</artifactId>            
     <version>3.5.4</version>        
     </dependency>

3.1.2 .配置mybatis的核心配置文件:在resoures下 面:SqlMapConfig.xml(名称自己起)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--&lt;!&ndash;头部文件:约束文件  作用是约束用户在配置的时候标签的先后顺序 &ndash;&gt;-->
<!--根标签-->
<configuration>
<!--    配置环境-->
    <environments default="mysql">
        <!--            default和id必须保持一致-->
        <environment id="mysql">
<!--事务管理控制器:jdbc管理事务-->
<!--            数据源:UNPOOLED  不用自带的连接池
                        POOLED:  mybatis自带的连接池
                           JNDI  web相关的一种连接池-->
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--            配置数据源的一些属性,连接数据库的信息-->
                <!--            配置驱动-->
                <property name="drive" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/racemall"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>

            </dataSource>


        </environment>
    </environments>
    <!--当读取SqlMapConfig.xml文件的时候,需要加载映射文件xxxMapper.xml-->
    <!--配置映射器-->
    <mappers>
        <mapper resource="com/qf/mapper/AdminMapper.xml"></mapper>
    </mappers>
</configuration>      

3.1.3 定义mapper接口,作为数据访问接口

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--头文件的约束-->
<!--配置Mapper映射文件
        namespace:名称空间
            指定哪个接口的方法呢?
            接口的全限定名称-->
<mapper namespace="com.qf.mapper.AdminMapper">
    <!--查询所有用户列表-->
    <!--id:和接口中的方法名要一致: 才能定位到具体的方法上
            parameterType:指定的是输入映射参数
              和当前接口中的方法的参数类型一致  :如果int,书写java.lang.Integer/Integer...
                                                    String.书写java.lang.String/String

            resultType:输出映射参数
                    返回的List :需要返回的list集合中泛型的类型的全限定名称
                    返回字符串,输入映射:String,java.lang.String
                    insert – 映射插入语句。
    update – 映射更新语句。
    delete – 映射删除语句。
    select – 映射查询语句。
    -->
<!--    查询所有管理员-->
    <select id="findAllAdmin" resultMap="com.qf.pojo.Admin">
        select * from admin
    </select>
</mapper>

3.1.4 单元测试

public class MyBatisTest {
    @Test
    public void findAll() throws IOException {
        //1)读取resources下面的核心配置文件
        //mybatis有一个类:Resources读取类路径下的资源文件---获取输入流对象
        //使用 MyBatis 的主要 Java 接口就是 SqlSession-->自实现类SqlsessionFactory
        // -->SqlSessionFactoryBuilder子类
        // 你可以通过这个接口来执行命令，获取映射器示例和管理事务
        InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");

        //2)获取SqlSessionFactoryBuilder:构建者对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        //3)获取SqlSqlSessionFactory 工厂对象
        SqlSessionFactory sqlSessionFactory = builder.build(inputStream);//解析核心配置文件

        //4)获取SqlSesison:执行对象
             SqlSession sqlSession = sqlSessionFactory.openSession(true);//自动提交,默认是手动提交
        //5)获取AdminMapper接口的子类对象: 底层动态代理实现   (jdk动态代理)
             // <T> T getMapper(Class<T> type);参数为接口类型的字节码文件对象
        AdminMapper mapper = sqlSession.getMapper(AdminMapper.class);
        List<Admin> list = mapper.findAllAdmin();
        //判断
        if (list!=null){
            //遍历
            for (Admin admin:list){
                System.out.println(admin.getAdminname()+"\t"+admin.getAdminpassword());
            }
        }
    }
 }

4 mybatis的查询功能

4.1 查询自增长ID

select insert_last_id; sql语句

insert标签中有子标签selectkey
	属性:keyproperty:实体类中的属性值
		keycolunm:表中的主键字段--id字段
		order:什么时候执行selectkey标签中的语句-->AFTER:代表在执行插入之后,执行selectkey的语句,获取最后一次自增长主键的id值

4.2 模糊查询

${}:字符串拼接符号
占位符:  #{}(推荐使用)
模糊查询: %${value}%

select * from user where name like #{name}

4.3 高级查询

mybatis支持 OGLD语言,访问的时候可以QueryVo对象.getAdmin().getName();
封装的QueryVo来直接查询
public class QueryVo(
	private Admin admin;
	提供set/get方法
)
那么在映射器mapapp.xml中的sql语句
	select * from admin where name like #{admin.name}

5.导入日志文件

在resource目录下导入日志文件-->mylog.log,需要在mawen项目下的resource目录下导入log4j.properties配置文件,将配置文件中的	log4j.appender.LOGFILE.File=D:/EE_2113/day58/resource/mylog.log	路径改为自己项目地址的下的mylog.log路径,同时需要导入log4j的jar包
  <!--导入log4j的jar包-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

6.传统dao方式–使用mybatis操作的弊端

传统dao方式的弊端:
	1)开发过程还需要核心配置文件,也需要映射文件,代码量大,还需要提供接口的子实现类
	2)从内存角度考虑,以后需要在业务层需要频繁的创建接口子实现类对象,不断的开辟对内存空间
	3)程序之间出现了耦合性,耦合性是解决不了的,只能降低耦合性,而mapper代理实现了底层动态代理

7.mybatis的注解开发的使用流程(并非纯注解)

在核心配置文件中,如果用注解开发,就不需要映射配置文件了,在核心配置文件中的映射器mapper时,属性是class:
	class属性直接显示接口的全限定名称
<mapper class=""></mapper>
	接口中:@select(sql语句)-->代替了Xx.xml映射文件中的select标签

8.通过外部资源文件加载驱动的方式—jdbc.properties

mybatis的属性设置:--> 加载类路径下的其他properties配置文件-->属性:resource="指定资源目录下的配置文件名称"
	 <properties resource="jdbc.properties"/>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="jdbc.driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>


            </dataSource>

        </environment>
    </environments>

9.mybatis的xml配置方式–在核心配置文件中配置实体类的别名包扫描以及mapper的别名包扫描–typeAliases

别名配置-->也是核心配置文件中的属性,给java中的实体类的进行别名配置,但是对单个实体进行别名配置太麻烦,采用别名包扫描---> <package name="com.qf.pojo"/>
<typeAliases>
        <!--type:别名:尽量小写,不区分大小写的
                alias:当前这个实体类的全限定名称
                
               随着实体类越来越多,那么单个别名配置太麻烦了
        -->
       <!-- <typeAlias type="student" alias="com.qf.pojo.Student"/>-->
        <!--别名的包扫描
            它直接将实体了所在包指定,别名默认就是当前类名小写,(一般不区分大小写)
        -->
        <package name="com.qf.pojo"/>
        
    </typeAliases>
    
   mapper.xml的别名包扫描-->将包内的映射器实现接口全部注册为映射器,因为映射文件和接口的包结构一致,自动扫描.就是将所有的映射文件都是为映射器,直接自动扫描映射器包就好了
   <mapper>
   		<package name="com.qf.mapper">--?也就是映射文件的文件夹路径
   </mapper>

10.一对多和多对多的映射关系(xml配置/注解配置)

账户表和用户表的之间的关系:
	一个用户可以拥有多个账户:一对多
	一个账户从属于某个用户:一对一
角色表和用户表之间:多对多关系,他们之间有一个中间表user_role
	一个角色可以赋予多个角色
	一个角色,包含多个用户

10.1 一对一的映射关系

 <!--mybatis方式 :配置一对一的映射关系 assocation
            property:账户表中的包含的实体类属性名称
            column:查询的时候,账户uid和用户的id 关系  列的字段-->从表的外键
            javaType：指定pojo中属性的类型，
        -->
         <association property="user" column="uid" javaType="user">
            <!--配置查询出的用户实体类他和表中的字段要一一对应-->
            <!--配置一对一主键字段-->
            <id property="id" column="id"></id>
            <!--其他普通字段-->
            <result property="username" column="username"></result>
            <result property="birthday" column="birthday"></result>
            <result property="address" column="address"></result>
        </association>

10.2 一对多的映射关系和多对多的映射关系

第一种情况:不使用懒加载,也就是collection中的select标签(不使用子查询)
多的一方配置 colllection
	  property属性:该实体类中包含的实体类集合名称
      ofType:将查询的数据封装到实体类中-->映射到list集合属性中pojo的类型
      column:查询的时候主表与从表的关系,是子表中与父表关联的外键
      		<mapper namespace="com.qf.mapper.UserMapper">
      			<resultMap id="usermap" type="user">
      				<id property="id" column="id"/>
            <result property="username" column="username"></result>
            <result property="birthday" column="birthday"></result>
            <result property="address" column="address"></result>
          		 <collection property="accounts" ofType="Account" column="id">
                 <id property="id" column="aid"/>
             <result property="uid" column="uid"/>
               <result property="money" column="money"/>
            </collection>
        </resultMap>      
第二种情况:使用懒加载,,也就是collection中的select标签被使用(使用子查询)
	  property属性:该实体类中包含的实体类集合名称
      ofType:将查询的数据封装到实体类中-->映射到list集合属性中pojo的类型
 (重点) column:select中子查询的条件列名-->也就是子查询中,匹配到父表的条件列-->父表的主键id
 		<mapper namespace="com.qf.mapper.UserMapper">
      			<resultMap id="usermap" type="user">
      				<id property="id" column="id"/>
            <result property="username" column="username"></result>
            <result property="birthday" column="birthday"></result>
            <result property="address" column="address"></result>
            <collection property="accounts" ofType="Account" column="id"-特别注意
                        select="com.qf.mapper.AccountMapper.findAccountById">
                   </collection>
        </resultMap>

11.mybatis中的其他高级使用注解@param参数绑定/map集合作为方法的形参

(1)参数绑定:mybatis提供了一个注解@param
		特点:在两个或者多个参数时,参数绑定可以在映射文件中不写输入参数
	@param("绑定的别名") 绑定的参数-> Student findStudentByNameAndAddress(@Param("name") String name,@Param("addr") String address) ;
	在映射文件中,where name = #{name} and address = #{address}
	测试类中,直接执行方法
(2)参数类型为复杂类型的时候,比如map,在测试的时候,添加一个map并且赋值就好
	Student findStudentByNameAndBirthday(Map map) 
	在测试类中封装一个map即可

12.mybatis中,连接池(自带的)–可以自定义德鲁伊druid连接池

自定义一个类,让他继承自mybatis的数据源工厂类PooledDataSourceFactory,在这个类中,提供构造方法,创建德鲁伊的数据源对象
注意:在使用自定义连接池时,会不断提示消息,可以在editor里头的inspection中找到SQL.取消勾选SQL | No data sources configured  和 SQL | SQL dialect detection即可
public class MyDruidDataSourceFactory extends
        PooledDataSourceFactory {

    //构造方法
    public MyDruidDataSourceFactory(){
        //创建德鲁伊的数据源对象\
        this.dataSource = new DruidDataSource() ;
    }
}

相应的,jdbc的外部驱动资源文件jdbc.properties中,key值使用相应的德鲁伊的驱动参数名称
	jdbc.driverClassName=com.mysql.cj.jdbc.Driver
	jdbc.url=jdbc:mysql://localhost:3306/myee_2113?characterEncoding=utf8
	jdbc.username=root
	jdbc.password=123456
	jdbc.maxActive=10
在核心配置文件中,环境配置中DataSource的数据源类型填写自定义的德鲁伊连接池的全限定名称
	  <dataSource type="com.qf.datasource.MyDruidDataSourceFactory">

                <property name="driverClass" value="${jdbc.driverClassName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
                <!--最大激活数量-->
                <property name="maxActive" value="${jdbc.maxActive}"/>
            </dataSource>

13 mybatis的高级映射–resultMap

当表中的字段和实体类的属性名称不对应的情况下
方式一:起别名
	在查询的时候不要使用*.而且给出具体的字段名称 别名和实体类的属性名称一致即可
方式二:resultMap(使用场景:1)当实体类属性和字段不一样 2)mybatis多表查询的时候可以用)(推荐)
首先在映射文件中定义resultMap,然后再具体的增删改查,查询语句中将resultMap引入,resultMap里面就是可以将每一个字段和实体类的属性一一映射
	定义resultMap-->(1)id:resultMap它的标识id (2)type:就是实体类的全限定名称/别名  (返回值类型)
	配置主键字段: 表中主键字段 id 和 实体类的属性 id一致
            property:实体类的属性名称 id属性-->与表中字段的主键字段相对应
            column:表中字段列的名称	主键id
            普通字段和实体类的其他属性名称一一对应
            
      <resultMap id="myMap" type="student">
        <id property="stuId" column="id"></id>  
        <result property="stuName" column="name"></result>
        <result property="stuAge" column="age"></result>
        <result property="stuAddress" column="address"></result>
        <result property="stuBirthday" column="birthday"></result>
    </resultMap>

14.动态SQL语句

带条件查询的时候,只有当条件不为空的时候才能查询,mybatis提供了动态的sql语句,常用的几个动态sql语句:
(1)if
	 test属性:判断当前实体类型的属性是否满足条件,true还是false,true则执行,
	  select * from student where 
      	<if test="stuName!=null">
             name = #{stuName}
         </if>
         <if test="stuAddress!=null">
            and  address = #{stuAddress}
         </if>
(2)sql片段-->将公共的sql语句抽抽取出来
<sql id="mysql">
        select * from user
    </sql>
    在select标签中就可以直接使用sql标签
    	<include refid="mysql"/>

(3)foreach
	foreach标签里面有一些属性:
		1)Collection:当前实体类中封装的集合属性名称
		2)open:使用子查询 in(x,x,x) 以什么格式开始查询,比如 open="id in ("
		3)separator:分割符号
		4)lose:以什么格式结束	比如: close=")"
		5)item:循环遍历过程中的变量名称	item="变量名"
			foreach中间的内容
                            #{item里面指定的变量名称}
        <foreach collection="ids" open=" id in(" separator="," close=")" item="id">
                   #{id}
            </foreach>

15. mybatis提供 懒加载(按需加载或者延迟加载)/立即加载(默认的)

    setting配置
    name=“lazyLoadingEnabled” 是否开启延迟加载(全局延迟加载开关),value的值–>默认为false,不开启延迟加载,属于立即加载
    name=“aggressiveLazyLoading” （在 3.4.1 及之前的版本中默认为 true）,按需加载,calue的值–> true,每个调用的方法都会按需加载, false:指定的方法让需加载

13.servlet和mybatis进行整合(应用操作上)(完全仿照jdbcutils)

将mabatis和servlet整合主要就是将数据访问层通过mybatis进行优化,则在服务层需要获取mapper的接口对象.则需要定义获取sqlsession和mapper对象的工具类
	public class MyBatisUtils {
        //创建一个ThreadLocal<SqlSession>执行对象---->底层获取连接对象 控制事务
    private static ThreadLocal<SqlSession> t1 = new ThreadLocal<>() ;
    private static SqlSessionFactory sqlSessionFactory ;//声明了
    private static SqlSession sqlSession ;


    //构造方法私有化
    private MyBatisUtils(){}

    //静态代码块
    static{
        //1)读取核心配置文件
        try {
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            //创建sqlSessionFactoryBuilder对象: 构建者
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder() ;
            sqlSessionFactory = builder.build(inputStream) ;
            //创建执行对象
            sqlSession = sqlSessionFactory.openSession();//开启手动提交
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //定义功能,获取执行对象SqlSession
    public static SqlSession openSession(){
        //每一个线程都是自己的SqlSession
        //从当线程中获取SqlSession
        SqlSession sqlSession = t1.get();
        //判断如果null ,
        if(sqlSession ==null){
            //获取SqlSession对象,从sqlSessionFactory创建SqlSession
            sqlSession = sqlSessionFactory.openSession();
            //将获取的sqlSession绑定到当前线程上
            t1.set(sqlSession);

        }
        return sqlSession ;
    }

    //关闭SqlSession资源
    public static void closeSqlSession(){
        // //从当线程中获取SqlSession
        SqlSession sqlSession = t1.get();
        sqlSession.close();
        //将它从本地线程中进行解绑
        t1.remove();
    }
    //提交事务
    public static void commit(){
        //调用自己的封装openSession
        SqlSession sqlSession = openSession();
        //手动提交事务
        sqlSession.commit();
        //将sqlSession关闭
        closeSqlSession();
    }

    //回滚事务
    public static void rollback(){
        //调用自己的封装openSession
        SqlSession sqlSession = openSession();
        //手动提交事务
        sqlSession.rollback();
        //将sqlSession关闭
        closeSqlSession();
    }

    //通过mybatis动态代理获取接口地下
    //返回的类型:可以是任意Java对象
    public static <T extends Object> T getMapper(Class<T> clazz){
        //获取代理对象
        return sqlSession.getMapper(clazz) ; //mybatis动态代理
    }

}