yinzhuoei_seho 发布的文章

u=1194465232,98399045&fm=26&gp=0.jpg
百度了一下:
首先我们了解一个名词ORM,全称是(Object Relational Mapping),即对象关系映射。ORM的实现思想就是将关系数据库中表的数据映射成对象,以对象的形式展现,这样开发人员就可以把对数据库的操作转化为对这些对象的操作。Hibernate正是实现了这种思想,达到了方便开发人员以面向对象的思想来实现对数据库的操作。

首先hibernate在实现ORM功能的时候主要用到文件有:映射类javabean,映射文件hbm,数据库配置文件cfg

下面介绍一下每个的作用:

映射类javabean:能够把表中的字段描述成属性,描述了数据库中的结构,可以把数据库中数据映射成对象来供我们的操作。
映射文件hbm:描述了表中所有的属性和javabean中的关系,包括结构,属性,字段等等,是映射成对象必不可少的条件
数据库配置文件:描述了数据库信息,包括方言,连接url,账号和密码,以及连接入口和与映射文件hbm的主要组成部分。

在hibernate中一共有7种映射关系:

1.一对一单向关联映射

有2种策略实现一对一的关联映射:
分别是主键和外键

主键:

口述:让两个表有相同的主键进行关联,数据库没有额外的字段来维护他们的关系,也没有其余的表来维护关系

外键:

口述:本来是多对一的配置,也可以用来表示一对一的关系,其实也就是多对一的特殊情况。

2.多对一的单项

口述:即在多的一方加入一方的外键,指向一的一方,由多方维护关系

关键配置代码:

1. 

<many-to-one name="group" column="groupid"/>

3.一对多的单项

口述:其实是与多对一的方向不一样,即在一方加入多方的外键。

在一对多的情况下,要在一方容纳多的数据,要定义set集合,要在配置文件中配置一下

1. 

<set name="students">

2. 
  <key column="classesid"/>  
3. 
  <one-to-many class="com.hibernate.Student"/>  
4. 

</set>

set中的name指的是在一方实体类中定义的集合名称,key指本类的主键,one-to-many中写入class路径是,多方的路径

缺陷:因为多的一端Student不知道Classes的存在(也就是Student没有维护与Classes的关系)所以在保存Student的时候关系字段classesid是为null的,如果将该关系字段设置为非空,则将无法保存数据,常用解决办法是改用双向关联映射

4.多对多的单项

如果要维护多对多的,那么就要额外一张表来维护,才能完成基本的映射关系

把两张表的主键,放在一张表中,可以通过id来查询2边的信息

1. 

<set name="roles" table="t_user_role">

2. 
 <key column="user_id"/>  
3. 
 <many-to-many class="com.hibernate.Role" column="role_id"/>  
4. 

</set>

单项多对多,可以任意地在一个hbm中加入以上代码

5.双向一对一主键和外键

对比单项一对一来说,只需要加入<one-to-one>标签即可,它不影响,它只会影响加载速度

主键配置:

1. 

<one-to-one name="person"/>

外键配置:

1. 

<one-to-one name="person" property-ref="idCard"/>

简要讲述一下外键配置的内容:name是对方的类名,property-ref是本类的主键,充当person类的外键,来保持关联

6.双向一对多

双向一对多是为了解决单向一对多的缺陷而设计的。

hbm配置方法

在一的一方配置set配置文件,在多的一方配置many-to-one

1. 

<set name="students"inverse="true">

2. 
   <key column="classesid"/>  
3. 
  <one-to-many class="com.hibernate.Student"/>  
4. 

</set>

1. 

<many-to-one name="classes" column="classesid"/>

其中的inverse属性本意是反转,如果为true说明本端不能维护关系,为false说明本端可以维护关系

值得注意的一点是:inverse是控制方向的反转,只影响存储

通常是在多的一方维护关系,所以一般反转都会打开。

7.双向多对多

和单向多对多的区别就是,要同时维护关系,而且加载资源的时候也要同时加载,即也要同时配置

注意的是:

生成的中间表名必须一样,字段必须一样

1. 

<set name="users" table="t_user_role">

2. 
   <key column="role_id"/>  
3. 
   <many-to-many class="com.hibernate.User" column="user_id"/>  
4. 

</set>

1. 

<set name="roles" table="t_user_role">

2. 
  <key column="user_id"/>  
3. 
  <many-to-many class="com. hibernate.Role" column="role_id"/>  
4. 

<set>

最后的总结:首先双向一对多的映射,是用的比较频繁的,所以要彻底领悟几种映射关系,需要多敲代码

转载请说明出处和网址

QQ截图20180825190050.png

效果图在上面
小demo的坑:

图一共是5张,但是如果用计时器往左偏移的话,偏移到一定程度的时候,偏移位会归零,归零的瞬间会变图,
突然切换的图片会显得很生硬,所以再图片末尾再加上前2张图片,让滚动更流畅。

用到的主要技巧就是,计时器的技巧,还有就是jq的siblings()获取非当前的这个方法在触摸图层会很重要。

fadeTo方法也是非常重要的,传递2个参数,第一个是时间,第二个就是透明度,透明度我们选择了0.5,然后
ul的背景是黑色的,所以呈现出来的就是类似于黑色蒙版的东西。

源码附带:

<!DOCTYPE html>
<html lang="en">
<head>

<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>无限循环滚动轮播</title>
<script src="jquery-3.0.0.js"></script>
<style>
     *{
         margin: 0;
         padding: 0;
     }
     div{
         /* 图片一张是590 */
         width: 1180px;
         height: 470px;
         border: 1px solid black;
         margin: 100px auto;
         overflow: hidden;
     }
     ul{
        /* ul要存放7张图片,所以宽度要乘五 */
         width:4130px;
         height: 470px;
         list-style: none;
         background: black;
     }
     li{
         float: left;
     }
</style>

</head>
<body>

<!-- 思路 -->
<!-- 准备一个div -->
<div>
    <!-- div作为外面最大的容器 -->
    <!-- 图片放在ul中跟随移动 -->
    <ul>
        <li><img src="1.jpg" alt=""></li>
        <li><img src="2.jpg" alt=""></li>
        <li><img src="3.jpg" alt=""></li>
        <li><img src="4.jpg" alt=""></li>
        <li><img src="5.jpg" alt=""></li>
        <li><img src="1.jpg" alt=""></li>
        <li><img src="2.jpg" alt=""></li>
    </ul>
</div>
<script>
    var off=0;
    var timer;
        //jq代码让图片轮播
        $(function(){
            //设置变量获取偏移
            //调用自动播放的方法
            autoplay();
            //监听鼠标
            listen();
        });
        /*将计时器方法单独定义*/
        function autoplay(){
            timer=setInterval(function(){
                //进入定时器让off自减,向左走
                off+=-1;
                //判断,如果经过5张以后循环
                if(off<=-2950){
                    off=0;
                }
                 //获取ul
                 $('ul').css({
                     'marginLeft':off
                 });
            },10);
        }
        function listen(){
            $('li').hover(function(){
                //移入
                //移入之后给非当前选中的添加蒙版
                //移入停止滚动
                clearInterval(timer);
                //fadeto方法,设置动画透明度.ul背景是黑色的,li透明就是黑色朦胧感觉
                $(this).siblings().fadeTo(100,0.5);
                //选中当前要去除自身的蒙版
                $(this).fadeTo(100,1);
            },function(){
                //移出
                //继续滚动,调用方法
                autoplay();
                // 去除所有的蒙版
                $('li').fadeTo(100,1);
            })
        }
</script>

</body>
</html>

java反射机制运行状态中,对于任何一个类,都可以知道这个类所有属性和方法,对于任何一个对象,都可以调用它的任何一个方法,
这种动态获取信息或者动态调用功能称之为反射机制

获取Class的四种F方法:

例子:

                                                  //获取Class—getClass方法 
                                          test ts=new test();
                                       Class cl=ts.getClass();
                                          System.out.println(cl);
                                              //获取Class—Class.forName方法  
                                                 try {
                                                              Class cl=Class.forName("com.entity.test");
                                                              System.out.println(cl);
                                                    } catch (ClassNotFoundException e) {
                                                              // TODO Auto-generated catch block
                                                           e.printStackTrace();
                                                   }
                                              //获取Class—类名.class方法 
                                                             Class cl=test.class;
                                                             System.out.println(cl);
                                              //获取Class—包装类.type
                                                                        Class cl=Boolean.TYPE;
                                                                        System.out.println(cl);

推荐getclss方法和类名直接.class方法。
1.Filde类,获取成员属性

                                               //1.Filed类获取成员变量
                                              //2.获取Class
                                                        Class cl=test.class;
                                                        Object obj=cl.newInstance();
                                                        //获取指定对象
                                                        Field name=cl.getDeclaredField("name");
                                                        //公有化
                                                        name.setAccessible(true);
                                                        //拿到值
                                                        System.out.println(name.get(obj));

PS:文字说明【首先先拿到Class,然后通过test类中的无参构造函数来获取对象newInstance(),然后用Class获取名为name的属性,然后破坏封装 name.setAccessible(true); 然后通过Field对象从test对象Obj中拿到name name.get(obj)】
2)获取全部属性变量

                                                        //1.Filed类获取成员变量
                                              //2.获取Class
                                                        Class cl=test.class;
                                                        Object obj=cl.newInstance();
                                                        //获取指定对象
                                                        Field fields[]=cl.getDeclaredFields();
                                                        //循环里面的内容
                                                        for (Field field : fields) {
                                                                  System.out.println(field.getName());
                                                        }
1. 

获得Methods全部方法

                                                        //获取Class
                                                        Class cl=test.class;
                                                        Method me[]=cl.getDeclaredMethods();
                                                        for (Method method : me) {
                                                                  System.out.println(method.getName());
                                                        }
2)获得Method某个方法,不带参数
                                                        //获取Class
                                                        Class cl=test.class;
                                                        Object obj=cl.newInstance();
                                                        //调用ccc方法
                                                        Method me=cl.getDeclaredMethod("ccc",new Class[]{});
                                                        Object re=me.invoke(obj, new Object[]{});

3)获得Method某个方法,带参数

                                                        //获取Class
                                                        Class cl=test.class;
                                                        Object obj=cl.newInstance();
                                                        //调用ccc方法
                                                        Method me=cl.getDeclaredMethod("ccc",new Class[]{String.class,int.class});
                                                        Object re=me.invoke(obj, new Object[]{"谢振坤",88});

3.构造方法,获取全部无参构造方法

                                                        //获取Class
                                                        Class cl=test.class;
                                                        Object obj=cl.newInstance();
                                                        //调用构造方法
                                                        Constructor gz[]=cl.getConstructors();
                                                        for (Constructor constructor : gz) {
                                                                  System.out.println(constructor);
                                                        }

1)获取单独的构造方法,无参

                                                      Class cl=test.class;
                                                      Constructor gz=cl.getConstructor();
                                                        test t=(test) gz.newInstance();
                                                        System.out.println(t);

2)获取单独的构造方法,有参

                                                      Class cl=test.class;
                                                      Constructor gz=cl.getConstructor(String.class,int.class);
                                                      test t=(test) gz.newInstance("张三",67);
                                                       System.out.println(t);

4.反射ARR数组

                                                        //获取Class,这里定义arr的数据类型
                                                        Class cl=Class.forName("java.lang.Object");
                                                        Object arr=Array.newInstance(cl, 5);
                                                        //通过reflact包中的Array来设置名为arr,第3个值为5
                                ![下载.jpg][1]                        Array.set(arr, 3, 5);
                                                        //通过reflact包中的Array来获取名为arr,第3个值
                                                        Object elem=Array.get(arr, 3);
                                                        System.out.println(elem);
                                            
            

                                                    
            

u=4055771136,79106349&fm=27&gp=0.jpg大家好,已经很久没有给大家发布文章了,因为最近在学习很多新东西,已经保存到自己的印象笔记,所以后续会持续给大家
补更的,因为明天就开学了,今天晚上就用jquery写了一个小小的下拉菜单的demo。

知识点:

jquery的siblings():取得一个包含匹配的元素集合中每一个元素的所有子元素的元素集合。

大白话就是:拿到非当前对象的所有对象

还有一个查找的方法是children:取得一个包含匹配的元素集合中每一个元素的所有子元素的元素集合。

大白话就是:拿到当前对象下的某某子元素

demo:案例代码:

<!DOCTYPE html>
<html lang="en">
<head>

<meta charset="UTF-8">
<title>Title</title>
<script src="jquery-3.0.0.js"></script>
<style>
    *{
        margin: 0;
        padding: 0;
    }
    .nav{
        width: 300px;
        list-style: none;
        margin: 100px auto;
    }
    .nav>li{
        border: 1px solid #000;
        line-height: 35px;
        border-bottom: none;
        text-indent: 2em;
    }
    .nav>li:first-child{
        border-top-right-radius: 10px;
        border-top-left-radius: 10px;
    }
    .nav>li:last-child{
        border-bottom: 1px solid #000;
        border-bottom-right-radius: 10px;
        border-bottom-left-radius: 10px;
    }
    .sub{
        display: none;
    }
    .sub>li{
        list-style: none;
        background: mediumpurple;
    }
    .sub>li:hover{
        background: red;
        border-bottom: 1px solid #fff;
    }
</style>
<script>
    $(function () {
        $('.nav>li').click(function () {
            //拿到二级菜单
            var $sub=$(this).children('.sub');
            $sub.slideDown(300);
            //拿到非当前的一级菜单的二级菜单
            var othersub=$(this).siblings().children(".sub");
            //让其他二级菜单收起
            othersub.slideUp(300);
        })
    })
</script>

</head>
<body>

1. /*溢出部分样式*/  
2. 

.txt-ell {

3. 
whitewhite-space:nowrap;  //强制在一行显示   
4. 
overflow:hidden;    //溢出的内容切割隐藏   
5. 
text-overflow:ellipsis; //当内联溢出块容器时,将溢出部分替换为…   
6. 
word-break:keep-all;  //允许在单词内换行   
7. 
color: red;  //这里我自己标识一下   
8. 
padding: 0 7px;  //由于想跟边线留有距离,所以设置了下   
9. 

}

10. 

.table-fix {

11. 
table-layout:fixed;     
12. 

}

首先第二个样式是专门给table标签加的,想要实现内容溢出,那么表格必须有固定的宽高,表格内部的tr,td也要有固定的宽高。在用内容溢出之前,先要给table添加table-fix这个类。然后检查自己的tr,td有没有给width,如果没有的话,最好是给个吧,固定的也行,百分比的也行,我主要给的百分比,外边table给固定宽度,里面的tr和td就是百分比的宽度,这样才能使用内容溢出样式。最后如果哪个格子里面的内容非常的多,你想实现点点点,就给这个格子添加一个.txt-ell的类吧

下载.jpg