初级Java学习笔记总结

java高并发解决方案:
    1.页面静态:静态访问消耗的资源少
            信息录入然后生成静态页面以供访问
    2.数据库集群和库表散列
            主-从数据库关系;将各个功能的表分类放到单个数据库中,减少访问压力;
        注意的是:使用同一的算法监视数据库的状态,将自动增长的字段去掉,id要使用同一的算法集中的分配,使用非持久性连接
    3.缓存
        基本的缓存,自带的MemoryCache
    4.均衡负载
        集群的均衡负载,通过算法,分配服务器的访问压力
    5.镜像
        电信网通的例子,在两个节点放置镜像,实时更新
    6.图文分离
        图片放到其他的服务器上,减轻访问压力    


    装饰设计模式:核心是在构造方法中传参! 静态代理
!!不要把事件和属性混淆 在事件触发时要用到属性 所以不能使用属性的改变来调用方法
!!使用this的时候要注意代码的执行顺序 比如 table.οnmοuseοver=function(){this.style.backgroundcolor="red"}
!!!如果使用frame框架的话,有时候会出现主页只能显示在一个frameset中,需要判断最外的地址栏和跳转地址栏是否相同,如果不同就赋值;
//将当前子窗口的地址赋值给window窗口
    if(top.location!=self.location){
        top.location=self.location
    }
    返回上次打开的页面:<input type=button οnclick="window.history.back()">
    !!!!!!Eclipse 打不开的话修改配置文件参数为一半!!!!!!!!     mysql的跳过登录检测:mysqld下的skip-grant-tables;
    编码和解码都是以字节为单位的
    !!!!#接口是规范,软件是实现#
    异常之间如果需要转换的话(编译时异常转运行时异常),继承相应的类就好了
    序列化接口会因为版本不同导致读取出问题;
一     Html语言(不同浏览器对html语言的解析是不同的 标准一般是谷歌)
       Hyper text mark-up language  超文本语言
       标签  map标签的使用
             锚点的使用
             超链接的各种用法
       placeholder 提示"请输入用户名"
      默认值一般都是value,但文本表单的默认值直接在标签体中填写就好
         readonly 只读  数据会提交
         disabled 不可用 数据不会提交
             提交时 method=get 地址栏可以容纳的字符数目有限 1-2kb
             post提交时理论上无限制
二     CSS  Cascad style sheet 层叠样式表
     CSS  优先级  范围越小优先级越高
            display属性 inline-block 替代浮动
     一但使用position,对象就可以点出来上下左右四个属性可以设置多少px,直接确定位置;
三     JavaScript(初始化多个定时器 注意时间 定时器的参数(方法名 或者"方法名()"))
       组成  ECMAScript 提供核心语法
           BOM  浏览器
            DOM  具体文档对象
       JS中的数据类型
                   String 字符串类型 单双引号表示的都是字符串类型
               number  数字类型
               boolean 布尔类型
               undifined 未定义 已声明但是没有赋值
               null    引用类型的默认值  "NaN"==NaN false
            比较运算符 == 只比较值
             === 比较值和类型
       JS中的函数特点
        1.函数覆盖
          函数的参数不需要声明
          函数的调用和声明与参数没有关系
        2.参数按顺序传入args数组
       JS中二维数组的定义
          arr0=new Array()
          arr1=new Array()
         arr2=new Array()
         arr3=new Array()
         var arr=new Array(4)
       html一行一行的执行,一定要把大数组写在下面;
    !!window.confirm("");确认信息
    !!focus()方法     一般是通过ID获得对象来使用onfocus() (失去焦点和获得焦点和innerHTML的结合使用)  可以 通过JS中的双或  定义ID字符串 str=""|| "123";
        前面为空取字符串 前面不为空取前面;这个特性可以使得第一个报错的元素获得焦点
    !!避免方法重复过多,选择传参!!!!!!!
    !!在标签内传this参数是为了省去获取对象这一步骤,this指当前对象 谁调用就是谁 但是在script方法中因为调用者不确定所以不能写
    !!对象.属性 属性是字符串的都需要去掉单位才能计算;用parseInt()转化成number类型;
    !DOM对象的insertBefore方法   父节点对象.insertBefore(新节点,老节点);
       doument.forms[0].onsbumit       事件绑定的新方式
       JS的字符串转对象的方法:
       eval  将字符串转为对象 解析时有特殊的格式(前后必须加两个半个括号);
             将字符串转为可执行的脚本语言
============================================================================
!!jquery对象底层是只有一个js对象的数组(一切皆数组)
!!因为底层的数组结构 所以jQuery的方法不会被覆盖  长度length和size()都能用
!!script标签内 先加载jQuery页面加载函数不会被覆盖(页面加载函数可以都多个按顺序执行) 再加载js函数会被覆盖 window.onload只能有一次
!!js的onload在一个页面只能被赋值一次 而jQuery的ready可以多次使用(动态绑定 必须写页面加载)
!!jQuery中绑定事件没有on  方法中的参数如果被[]包裹 可以省略 没有的不行
        //加载事件 load  $(window).load();
!!style被css取代 传入键值对改变样式
!!选择器加冒号的(:)只有和表单有关有关的和基本的关键字 其他的不要用 切记!!
           基本类型
          层级选择器
          基本过滤选贼器
           基本属性选择器
          表单属性选择器
!!!this永远代表DOM对象 强制类型转换成JQuery对象 $(this) 回转用$(dom)[0]或者 $(dom).get(index)

        JQuery中的CSS语法  1.获取 对象.css("key")
                           2.设置 对象.css("key","value")
                           3.批量设置 链式操作
                  键值对数组类型 css({key:value,key:value})
                           4.css类 addClass("")  分离JQuery和CSS(就近原则使用)可以顺便给标签添加类型
        removeClass
        prop(key,value) 只能处理固有属性
        attr(key,value) 可以处理所有属性
        JS中的each循环  $.each(要遍历的对象,function(索引,值){});
        jQ中的remove()方法 移除自己
================================================================
        1.html和text在写入和获取时内容是相同的
        2.val(一个方法两个用途)(获取多个 打印第一个)
        3.append 向后
          prepend 向前
        4.jQuery的对象创建var s= $("标签"); 数组形式
        5.链式操作类似于java中的方法连续调用 明确对象和对象可以调用的方法即可;
        6.事件的转换 hover(css中鼠标移上效果关键词)(fn1,fn2)
                toggle(fn1,fn2,fn3)(1.83版本的)
        7.表单校验规则  注意事项:key:value,      使用的是name属性
                    1.类校验规则  class=要求;
                    2.属性校验规则 将校验类型自定义为属性
                    3.data校验规则 加data-rule-;
                    格式:data-rule-校验器名称="值"
                4.静态校验:记住格式;属性值都可替换为true和false;
            * 底层通过 $(ele).data("ruleRequired")获得数据
        8.自定义校验格式
                $.validator.addmethod(校验规则名称,校验方法,提示{0}信息{1})
                                 function(输入内容value,当前标签ele,规则参数params){}
                    行内样式的优先级要高一些
                    优先级:css(key.value)>对象.addClass
        9.查找
             children() 子元素
             closest    首先检查当前元素是否匹配,如果匹配则直接返回元素本身。如果不匹配则向上查找父元素,一层一层往上,直到找到匹配选择器的元素。如果什么都没找到则返回一个空的jQuery对象。
             parent     取得一个包含着所有匹配元素的唯一父元素的元素集合。
             siblings   所有同辈元素
             offsetParent() 作用于最近的父元素
             next() nextall() 后面
             prev() prevall() 前面
        10.id和方法名不能重复但是可以和name重复;

        11 jQuery不属于W3C规范,隐藏方法是hide,处理命名冲突的方法是noconflict 设置高度 对象.height(数值)
============================================================================
    感兴趣的API $.makeArray(obj);将对象数组转为数组(相同的标签)
              css的jQuery API taggleClass() 如果存在就删除不存在就添加
              $.data()可以存储数据 不过在上面是看不到的 用removedata()移除数据
              $.extend(fn1,fn2....);定义自己想要的方法直接用(逻辑写清楚);
              $.empty() 删除对象的子节点
              $.remove(可以加条件) 删除包含对象的元素(无参数)删除对象中条件元素(有参数)
                  删除之后绑定数据和事件都不能使用了
              $.detach() 与remove的唯一区别就是删除之后的绑定的数据和事件都可以使用
              $.clone() 克隆元素 后面有boolean参数 是决定是否复制事件(1个) 决定是否复制元素的事件函数和所有子元素
    四    易错点
        1.在条件判断是需要用= =!!!
        2.定义数组用  var arr=new Array(1,2,2,3);
        3.var flag;如果没有赋值的话,是未定义的,所以必须初始化;
        4.:even筛选偶数(0,2,4) 找的是奇数行(1,3,5) ;
        5.addClass这个jQ方法使用时 添加样式类时必须写在style标签里面;
        6.backgroundColor=======background-color  在JS中-是警号
        7.data-* 是html5 的自定义属性
            $.attr(data-*)
            $.data(*)获取属性
        8.在使用方法时要注意加不加后面的括号 不加的例子{settimeout(fn,1000),$.validator.addMethod(注意里面的参数)
        9.var x=1;  x=1;全局    10.在装箱时,如果数值在byte范围之内,那么数值相同,不会产生新的对象,也就是说多个数值相同的引用指向的是同一个对象。
        11.TreeSet集合排序有两种方式,Comparable和Comparator区别:
            1)让元素自身具备比较性,需要元素对象实现Comparable接口,覆盖compareTo方法。
            2)让集合自身具备比较性,需要定义一个实现了Comparator接口的比较器,并覆盖compare方法,并将该类对象作为实际参数传递给TreeSet集合的构造函数。
                第二种方式较为灵活。
    bootstrap知识点:基于HTML CSS HE JAVASCRIPT
        1.引入顺序:先是bootstrap.min.css
          bootstrap-them.min.css
          jQuery 1.11.3版本最好
        2.栅格系统 响应式和流式布局
       行和列如果没有设置较大的值时采用小的 没有最小的默认12
       <div class="container"><div>
       visible和hidden 只会在设置阶段生效
        3.本模块规则影响最大化 比如轮播图的计时器

mysql知识点:单双引号都行 一般用单引号|||||数据库添加的其实是字符串,数字类型可以省略引号
     判空方式 不能直接等于null  用is null 空字符串
            聚合函数不统计null
            exsit  比in 效率高
    java的内嵌式数据库db4o.
    Andrion SQlite 嵌入式数据库
    db2:分布式数据库
    数据库控制语言DCL:权限回收和赋予, grant和revoke;

数据库的定义语言DDL:定义数据库及表结构
    数据库操作
        常用命令:
            create database 数据库名字 character set 编码
            show databases
            select database
            use database
            show create databases
            drop database 数据库名称
        表操作:
        常用命令:create table 表名称{字段 类型 限制}
            show tables
            show create table
        !!!!!desc 表名; 查看当前表结构
            drop 表名
        修改表:
            修改表结构 alter table 表名 add 字段名 类型 约束
                   alter table 表名 modify 字段名 类型
                   alter table 表名 change 字段名 字段名2
                !!!!!alter table 表名 drop 字段名
                   rename table 表名 to 新表名
                   alter table 表名 character 字符集(不推荐)
数据库的操作语言DML:操作表里的数据
        插入数据 insert into 表名 values(value1,value2)
              insert into 表名(字段1,字段2) values(value1,value2)
        修改数据  update 表名 set 字段1=value
        删除数据  delete  from 表名
              delete和truncate的区别
                    删除方式 delete一条一条删除 不清空主键
                    truncate直接删除表重新建立一个新的表 全部初始化
                    事务方面 delete 删除的数据 如果在一个事物中可以找回
                    truncate 删除的数据不能找回(一般不用)
数据库的查询语言DML:查询表里的数据
    limit的用法 select * from 表名 limit m,n(表示从m+1条开始读取n条)
    in的用法 select* from 表名 where 字段名 in{}
    exist的用法 if(exists){执行的sql语句}
    order by a, b,c(desc是默认的升序排列)
mysql的多表查询
    alter table 从表 add [constraint] [外键名称] foreign key 从表的外键字段
    refrerences 主表主键名称
    从表添加数据规则:不能添加没有主键的元素
             添加元素时外键可以为空
             删除时先删除从表数据
    主表数据可以随意添加,删除时只有在从表中此主键不被引用时为空的时候才能删除
    1.内连接
    普通的 select * from 表1 inner join 表2 on 主外键关系
          隐式   select * from 表1,表2 where 主外键关系
    内连接产生的效果是一样的,找到的是两个表的交集  顺序无所谓
    自连接其实就是内连接的改变,一般运用子查询的方式
    2.外链接
    左连接 select * from 表1 left outer join 表2 on 主外键关系

          右连接 select * from 表1 right outer join 表2 on 主外键关系
        外链接产生的效果不一定一样
      左连接和右连接的关系
    左连接以左表为主,把左表所有的数据全部查询出来,拼上右表的数据,找不到显示null


    一对一的创建原则 :创建外键(从表的主键)指向主表主键,必须在外键加上unique约束
    一对多建表原则:创建外键指向主表主键
    多对对建表原则:新建一张表至少有两个字段 指向至少两个表的主键

    外键的作用是保证数据的完整性
    外键的删除:删除命名过的外键    alter table 表名 drop 外键名
JDBCUtils 工具类中读取配置文件获取流的方法:ResourceBundle rb =ResourceBundle.getBundle("文件名")  文件名没有后缀
    Dbutils工具类只是提供一个QueryRunner的核心类可以自行通过连接获取与处理对象 并不是提供了连接
    DBCP连接池 利用工厂模式去搞一个数据源 类似于线程池的工厂方法
    C3P0连接池 提供数据源和额外获取单连接的方法()
This关键字的使用:在类的继承和接口的实现中 编译看左边运行看右边 父类方法中的this在编译时代表的是父类 在运行时代表的是子类 也就是new谁 this代表谁
              在构造方法中调用其他构造函数
数据库的控制语言DCL:权限的控制
子查询的概念:一条select语句的结果作为另一条select语句的一部分(条件,表,字段)

 
字段类型:int double datetime timestrap decimal
重点: select name,key,case when 条件 then 算法
                          when 条件 then 算法
                          else 算法 end
                          from 表名
show variables like '%char%' 显示当前编码
set names 编码 修改当前窗口
Junit不能测试静态方法,对语言的要求更加严格,必须符合命名规则;
所有的类中都加上构造方法!(会碰到类无法创建的异常,就找构造方法)
12.25    xml:
        schema约束:明确跟标签.xml可以引入很多约束文档
        名称必须全球唯一,一般使用公司域名+公司内部唯一;
        Xpath:获取单个的时候 是第一个符合条件的节点,直接返回
反射:动态语言的定义:在程序运行时,允许改变程序的结构和变量类型,即动态
    语言;
    动态语言:Perl,Python,Ruby;
    静态语言:C++,Java,C#
        Java的反射机制
    反射机制在使用无参构造的时候,可以直接用Class对象实例化,不需
要再获得无参构造方法;
    装箱和拆箱发生在编译阶段,反射机制是在运行时获取class对象,解
剖类
xml:用户可以自定义标签;
    xml文档声明:必须出现在文档的第一行
    <?XML 属性名="属性值" ?>
    version:必须有;使用1.0
    encoding:字符集  浏览器打开默认字符集默认utf-8
    standalone:描述文档是否需要依赖其他的文件
    xml的注释:和html一样的格式
    xml的语法:有且只有一个根节点,比html更严格
    xml元素的定义:不能和xml重复 不能使用数字开头 不能包含空格 不能包含冒号(:)
    xml的属性:命名规范和元素相同; 属性值需要引号包裹
    xml的特殊字符:会跟基本语法冲突,要转义
    CDATA区:所有内容都会成为普通文本解析
xml的解析:针对这两种解析方式,不同的公司提供了不同的技术
        JAXP:sun公司提供的套XML的解析的API
        JDOM:开原组织提供了一套XML的API-jdom
        DOM4J:开原组织提供的一套XML解析的API-DOM4J,拉过来一
条,不是自己想要的就放弃;
        SAX:一条一条的解析,
        pull:主要应用在Andrion手机端;

xml的解析方式:DOM解析:Dcument Object Model:将文档加载到内存形成

一个二叉树,当然会有节点,然后就能根据节点获得文本
缺点: 文档特别大的话 会很耗内存,容易导致内存的溢出
优点:解析很清晰,可以对XML进行增删改查;
             SAX解析:Simple for XML:事件驱动的方式进行逐行解析:
缺点:只能做查询
优点:不会导致内存的溢出
///各种类型的集合都是有迭代器的

DOM4J支持Xpath解析方式
使用Xpath解析的话 只能使用两个常用方法:Document.selectNodes(String

Xpath);参数是元素
                      document.selectSingleNode

(String Xpath);参数是元素

xml的约束:规范xml的写法
    xml约束的种类和级别:
        DTD和Schema
            区别:
             1.DTD语法是自成一体的,Schema语法就是xml语法
            2.Schema更容易被解析器解析,支持名称空间,DTD
不支持;
            3.Schema有比DTD更加强大的语义和语法的约束;

了解DTD:
    引入方式:内部和外部两种类似于js的引入 外部可以引入网络的规范
    内部格式:<!DOCTYPE 根元素 []>
    外部的:本地:<!DOCTYPE 根元素 SYSTEM "路径">
           网络:<!DOCTYPE 根元素 public "//名称/" "网络地址">
    Schema的引入:1.明确跟标签
                2.导入xmlns指向xsd文件的targetnamespace 命名空间(开辟空间的名称) 找第一个(可能不止一个约束)
                3.固定值 找第四个
                4.找第三个 名称和位置
Schema的名称空间是什么? 区分标签名的约束来自哪个约束文件  类似于jar包

HTTP HyperText Transfer Potocol 超文本传输语言
特点
基于请求/响应模式的协议,请求和响应必须成对;现有请求后有响应
Http协议的默认端口号是80;
版本
HTTP/1.0 发送请求,创建一次连接,获得一个web资源 连接断开
HTTP/1.1 发送请求,创建一次连接,获得多个web资源 连接断开
组成
请求协议:请求行-请求头-(空行)请求体(一般只有post会使用)
协议:响应行-响应头-(空行)响应体

请求:
常见的请求头:Referer 浏览器通知服务器当前请求来自何处
         if-Modified-Since
         Cookie  与会话技术有关,存放浏览器缓存的cookie信息
         user-agent 可以获得访问系统信息
常见的响应头:Location
         Content-Type  响应正文的类型
         Content-Disposition 通过浏览器以下载的方式解析正文 取值是可下载文件类型
         Set-Cookie 与会话技术相关,服务器向浏览器写入cookie
响应行的状态码:
    1xx
    2xx
    3xx:本次访问未结束,请继续操作
        302:服务器无法处理返回302,紧接着会给一个location地址
        304:读取缓存,服务器通知浏览器,浏览器已经有缓存,直接显示即可,此时响应协议没有响应体
    4xx:404 错误页面,无法找到,无法找到资源
    5xx:500:服务器程序错误;

netstat -ano 查看正在运行程序的端口号
tomcat服务器工作空间下的配置文件如果不存在,会自动遵循服务器配置文件

浏览器发送请求到服务器,服务器处理数据然后响应浏览器 是一个浏览器和服务器的交互过程,要清楚服务器的功能和浏览器的功能(html解析器),
    交互的过程中必须清楚两个对象之间的联系和各自的功能可以很好的利用
    在html中 <meta>这个标签可以模拟http的响应头,直接向浏览器写一个meta标签 也是666

####response笔记:
    处理编码:
        setCharacterEncoding 设置请求或者响应使用的码表(仅仅对post提交方式有用)只对请求体有效 get方式的数据在头中 所以没有
        response.setContentType("text/html;charset=utf-8");
        response.setHeader("context-type","text/html;charset=utf-8")
        通过构造方法编码解码  终端以什么解码就先以什么编码,http协议使用的是iso-8859-1的编码
        IE浏览器默认编码和操作系统是一样的(内核),与其他浏览器使用的使url编码
        火狐浏览器是base64编码(内核)
    ServletContext 项目上下文根对象,整个项目只有一个
        设置全局参数 整体修改比如编码
    配置文件写错的话 服务器会直接抛运行时异常,报错的
    ServletContext几个获取流和路径的方法 除了getResourcePaths 填的是本路径之外 其他的都是到项目根目录下的相对路径
Servlet的生命周期 :一个接口 Servlet
         两个实现类:GenericServlet
                    HttpServlet
         接口是定义规范
        GenericServlet实现了init(有参数)
        1.给config初始化
        2.调用无参数的init()
        结论:复写初始化方法时,应该复写无参的(让父类去执行有参的,然后调用子类的无参的方法),如果复写有参的 需要调用父类中的有参的init()
=======================================================================================================
        HttpServlet
        1.将ServletRequest 和ServletResponse强转成和协议相关的参数
        2.调用自己写的service 调用getmethod()方法 获得请求方式,然后根据获得的请求方式调用请求方式的方法.
        3.发送消息体时,字符流和字节流不能同时使用,互相排斥,IllegalStateExpection异常
        print底层是write;
        println是源码换行(在响应体中);
        4.文件下载:中文,命名的文件需要进行URL编码
    
    !获取服务器路径
        !获取文件名
        !发送下载头
        !读写
        5.随机图片
        @BufferImage的类 中的getGraphics方法 返回一个Graphics对象
        @然后draw图 各种东西都可以写(看要求) 时刻记得抽取方法
        @imageio(之前见过的)要搞清楚各个类和接口的继承和实现关系 面向对象的多态思想!!!
        @度和弧度的转变    度*3.14/180=弧度  度数可以用随机数的任意值%目标数 这样就正负都有了;
        !!!!注意的是浏览器会缓存页面 设置Header不缓存任何数据
        // 禁止缓存
        // response.setHeader("Cache-Control", "no-cache");
        // response.setHeader("Pragma", "no-cache");
        // response.setDateHeader("Expires", -1);Expires控制浏览器缓存:注意是必须是当前的时间,
        ###刷新按钮的作用,将上一次的请求重新发送给服务器
        %%点击切换图片的时候,就算重新赋值地址的话,也会读取缓存,需要搞一个全新的地址!
        6.javaScript代码不执行 加一句"javascript:void(0)" ;
url编码知识:浏览器用来打包表单输入的格式;
        在cmd中默认支持的是GBK编码 代号是936 而utf-8编码的代号是 65001 通过chcp命令就可以更改编码,注意要设置字体;
重定向的知识:
    常用的重定向方式有三种:sendRedirect(相对根目录路径),可以在不同的项目内使用
        301 redirect:301代表永久性转移(Permanently move),是网页更改地址后对搜索引擎友好的最好方法,只要不
                     是暂时搬离,建议使用301;
        302 redirect:302代表暂时性转移(Temprorarily Moved),暂时性转移域名作弊,比如访问过的一些***,你懂得,地址栏发生变化
        meta fresh 网页的meta命令
跳转:request.getServletContext().getRequestDispatcher(跳转的消息).forward(response,request);
          然后将数据放入Context中由JSP取出,利用浏览器识别的语言,进行跳转;
         ###还有一个include()包含的方法  将一个网页的相同的部分封装;被封装的部分不能有全局架构标签
请求转发:一次请求和响应,共享数据,在本项目内跳转,地址栏不加项目名,地址栏不发生改变
重定向:两次请求和响应,不能共享数据,可以调到项目外,地址栏加项目名,发生改变
获得项目名:getContextPath()
request:
    url:统一资源定位符,精确到绝对路径
    uri:相对来路径;
    头以及其信息的获得:Enumeration 迭代器的前身;
    post方式提交:1.处理简单.  2.参数可以任意设置   3.数据相对安全
    编码和解码是相对来说的!一切都是相对来说的!
    禁用脚本调试,跳过脚本语言

请求:请求行:提交方式+地址+?健值对信息+协议版本
    请求头:健值对的信息 都有方法获取
    请求体:健值对信息(提交的信息) get提交方法没有这东西
响应:响应行:协议版本+状态码+状态码描述
    响应头:键值对信息
    响应体:服务器发送给浏览器的原文 记住在servlet文件中换行的是这个换行 并不是显示在浏览器的内容换行


Beanutils 里的方法 一个是封装populate(对象,map)   还有一个复制对象copyProperties(对象1,对象2);

或许有用:防盗链:referer(可以)
    1.首先获得referer的头
    2.然后判断头的符合条件(主要是判断referer的来源)
    3.response.sendRedirect("路径");
web开发地址问题:以"/"开头:给服务器用 代表当前Web页面
        给浏览器用 代表网站 下面会有多个web应用 在加上工程目录就好了
        有四个匹配规则:完全匹配 目录匹配 扩展名匹配//*.扩展名 缺省匹配
获取硬盘的时候用反斜杠\\ 服务器资源的话用斜杠/

会话:访问web资源到关浏览器完毕就是一个会话;连接的建立到关闭;
session是基于cookie的,标志通过cookie存在客户端,具体通过session内容存在服务器

cookie  客户端技术 数据存在客户端,安全问题,不合适存中文 (一般存ID等)
        构造方法(name,value);
在服务器和客户端之间通过头的键值对形式传递;
设置cookie的有效期 setMaxAge()如果没调这个方法,默认是浏览器进程的时间;
设置带着数据访问的路径;默认是发出cookie的那个目录;
Cookie的删除即覆盖,同名cookie 时间设为0;

session 服务器技术 数据存在服务器为用户开辟的session:同一段代码不同的数据(多线程问题),服务器压力大,作用范围是一次会话;
    request.getSession();创建和查找;找到就返回,找不到就是用在手的资源创建;
session的销毁方式:
    1.非正常关闭服务器
    2.默认30分钟;最后一次访问开始计时;
    3.session.invalidate()销毁;

Cookie:一个Cookie只能表示一种信息,至少含有一个标示该信息的name和value;
    每个浏览器最多存储300个Cookie,一个站点最多20个,一个Cookie的大小最大是4KB;
如果没有cookie存储sessionID的话 会用其他的技术去识别用户,比如URL重写,将sessionID拼接在浏览器的路径后面;
                                                             作为查询字符串附加在URL后面;
                                                             隐藏域 不多用!
Session存到服务器没有大小和个数的限制
cookie 搞一个数组 回写给浏览器
服务器所有的响应其实都是servlet响应的
单列和双列容器,检索数据需求使用双列容器
表单重复提交的问题:客户端和服务器端的防范;
随机数的数据摘要:可以做到随机统一;
UUID的静态方法UUID 随机字符串;
2.jsp声明语句
定义用<%!%>   翻译到成员位置
1.JSP Scriptlets
输出用<%%>     翻译到Service方法内部 相当于方法
3.JSp表达式
<%=%>中间插入的是表达式,不能插入语句,JSP表达式中不能有;
4.JSP注释格式
<%--内容--%>

JAVA注释  存在于java源码和JSP源码 不存在于html源码
html注释 JSP,JAVA,HTML源码中都存在
jsp注释 只存在于JSP源码中,其他的都不存在

指令严格区分大小写
JSP的page指令:pageencoding 指定当前页面的编码格式;
contentype 客户端浏览器根据该属性判断文档类型;
buffer JSP缓存大小 默认8KB;out可以马上输出;
autoFlush  是否自动刷新
errorPage 自动跳转的错误页面,相对路径
iserrorPage 指定是否为错误处理页面 是的话会内置异常对象
import 唯一一个可以多次声明的指令;中间用逗号隔开;
language 解释文本的语言
session 指明是否内置session对象 默认为true 自动导入四大常用包 lang servlet servlet/jsp  servlet/http

pagecontext<request<session<application 域对象:向其他域中设置数据   findAttrabute()
include指令包含页面
<%@ include file="被包含文件的地址"%>  这个东西和request.ServletContext.getRequestDispatcher(被包含页面的路径).include();
<jsp:include  page="">

常用的对象之out
在整个JSP页面加载完毕之后才会将缓冲区的内容写入页面,通过设置buffer的大小可以马上输出;

访问的JSP在服务器的work目录中没有对应的servlet,就找JSPServlet翻译

静态资源的访问: 先找动态资源,如果没有通过缺省路径找到阿帕奇提供的DefaultServlet中自动寻找静态资源然后通过java代码写到页面上

问题:
    1.无状态;http是无状态协议,原因是不会对上次访问进行记忆,如果再次访问,需要重新传输,因此数据量大对服务器的压力比较大,此缓存技术就产生了
    2.根据用户存储和根据cookie和session存储数据?
    3.注册时间什么时候用? 在使用BeanUtils封装对象的时候,起将时间格式化成字符串的作用
    <%@ taglib uri="标签库相对地址" perfix="前缀"%>
  -1-10
pageContext提供了管理所有域的方法
exception config request response session pagecontext out application page;
javaBean:
    <jsp:useBean id="名字" class="加包名的名称" scope="范围"></jsp:useBean>
    这个标签和request.getSession一样 带着id去寻找 如果没有的话 会重新创建一个标签中可以写内容,但只有在bean实例化的时候才会执行;
    <jsp:setProperty name="要操作的bean的名字" property="属性名称" value="字符串或者拼接一个表达式"可以使用请求参数赋值 (param="name"支持8种基本数据类型的转换;)>
    数据类型转换的时候要注意不是8大类型的数据转换
    所有的请求参数的值全部赋值 名称必须一致
    <jsp:setProperty name="名称" property="*" />
    获取属性值
    <jsp:getProperty name="名称" property="属性名称" />
el隐藏错误,取不到显示的是空字符串不是null;
实际开发中null禁止向客户端输出;加判断,不输出;
浮点数只适合科学运算;
碰到不能编译的情况;考虑这个:刷新或者在工程中把需要的jar包放在lib下就好了 不要重复放在其他的文件夹下
JSP中取数据的时候用的都是反射技术;
el表达式:${} 取数据的时候通常用(.) 点不出来就用[] 里面的数字要加单引号;
MVC三层架构:开发步骤:javabean-dao-services-servlet-jsp;

el作用:
    1.取数据
    2.11个内置对象
    3.可以调用el函数库的函数
el取值:${name}
        ${name.["name(有特殊符号的)"]}
        如果按照${name.value(有特殊符号)} 取到的是0;
在表单提交过程中,文本框取不到值得话,得到的是空串(前提是name存在,不存在的是null), 其他的框取到的是(on);

JS的location对象的href页面跳转方法;客户端地址
如果没有向request中设置参数 尽量使用sendRedirect(客户端地址)

在页面定义的数据存放在page域中;

preparestatement  预处理对象   执行效率高 一次执行多个结构相同的数据;









  -1-11
数据库事务:事务的提交和内存数据库有什么关系?
        commit 事务结束;;
        rollback 事务不结束;
ThreadLocal:get(),set(),remove(),initialValue() 初始值!!
事务保存点:事务回滚到指定地点,只撤销部分操作;
            Savepoint sp=con.setSavepoint();
            con.rollback(sp);con.commit();
事务的特性:
    ACID:原子性-数据库中操作的最小单位
         一致性-事务的操作中数据是平衡的;
         隔离性-多个事务操作不会互相影响
         持久性-事务结束后的影响会永久保存在数据库中
事务的隔离:
read uncommitted
read committed  解决脏读      oracle的隔离级别
repeatable read  解决脏读和不可重复读  mysql的默认的隔离级别
seriazable  串行化 解决所有问题 效率很低
mysql支持四个事务隔离级别,orcle只支持前三个;

脏读:线程Y读到了其他线程未提交的数据
不可重复读:T线程读取到的数据被其他线程修改了
虚读幻读:T线程做了条件查询,其他线程做了满足该条件的插入或修改,导致T读取前后的数据的条数不一致;

联想到序列化流 对象实现序列化(将对象序列化到文件中 键值对 中间不能有空格)
批处理:
        ps.addBatch();
        ps.executeBatch();
StringBuilder的使用:有个吊用!!!
2.表查询和product的属性结合(内连接和外链接);
3.传参的时候要加引号;
4.JS中可以使用el;
5.只要是夺标查询,需要封装都要用map;
6.利用jQuery对象选中;
7.利用隐藏域传递需要的参数;
8.表单调用submit();
9.jQuery的循环看一下;
10.值对象封装散数据;  建在vo包下;
11.trim方法 字符串的方法 今天看一下微信上的Sring和StringBuffer;
12.数据类型的转换 封装的时候要注意!
13.数据的回显;
  -1-12
分页:
    物理分页:数据库层次上的分页,查询数据事分页
        优点:占用服务器内存资源少
        缺点:增加数据库和服务器的通信次数,增加可数据库查询的压力
    表中数据量大的时候选择
            格式:Mysql limit 关键字放在查询语句的最末尾
                    limit m,n; m是查询的起始索引下标
                                n是查询的数据条数
                    算法:起始索引=(当前页数-1)*一页有多少数据
                 Sqlserver top
                 Oracle:子查询三层嵌套rownum



    逻辑分页:把数据一次性查询到服务器内存中,在显示的时候写算法进行分页
        优点:只查询一次,减少通信次数
        缺点:java集合无法一次性保存过多的数据,常用内存
    数据量没有达到万级使用逻辑分页;


pageBean在service层生成!!
Count(*)  返回值是long型;
类型转换方法:想字符串就好了;
每次都全部按条件查询 然后封装到pageBean中
3.继承pageBean这个加泛型的类!
4.input和button的区别:
        input是Html服务器控件;
        button是web服务器控件 有其他的额外功能,不一定反映Html语法;
    两个东西一般是很难对其的,而且还会因为浏览器的版本不同产生不一样的效果;要对其的话要在外面套用其他行内标签,还有设置浮动之类的东西;

  -1-13
基本选择器  ID选择器 类选择器  层级选择器 属性选择器 表单属性(加:的那些)
checked  selected
同步发送:页面直接发送给服务器,在服务器响应返回之前,客户端处于卡死状态
异步发送:页面发送给浏览器内核ajax引擎再发送到服务器端,在服务器响应返回之前,客户端可以进行其他操作
Ajax:异步发送请求到服务器端;
        1.获得对象
        2.绑定监听(监听响应结果,监听服务器端的数据响应后主动给客户端的页面)
        3.指定请求地址
        4.发送请求

$.ajax({Type:"请求方式",
url:"请求路径",
data:{请求参数,键值对},
success:function(data){
    请求成功后(状态码是200)的回调函数
},
error:function(XMLHttpRequest,textStatus,errorThrown){
    XMLHttpRequet:AJAX的引擎,一般用不到
    textStatus:状态信息
    errorThrown:抛出的异常信息
 状态码为5XX或者4XX的回调函数;
}

})
$.get()
$.post()
为什么没有响应而data是一个空串?  有请求必定有响应吗?

eval()允许执行js代码; 第二个参数Unsafe是区分大小写的;
如果参数是值的话,返回的是值,如果参数是对象或者其他引用类型的话,返回的就是它的引用;
是不是所有的方法都可以重新赋值成变量,即改名???
jQuery的json格式的字符串必须使用双引号;
  -1-15
EasyUI:封装样式,和服务器进行数据交互;底层对Jquery的封装;
        1.静态方式:
                加class   easyui-组件名称
                使用data-option 设置键值对属性 类似于style的格式
        2.动态方式:
                使用Jquery获取对象,调用组件名称方法;
                $("#id").属性名称({
                    键值对属性;
                });
                 类似于validate的校验!!!!!!!!!
        3.三大元素:属性和事件可以写到一起(无关顺序);
            组件属性:
                静态和动态;
            组件事件:
                类似于属性;
            组件方法:
                对象.组件名称(方法名称,参数列表大括号内);
        fit属性 自适应父容器;
常用组件:
    dialog-------messager-----datagrid-----form----layout(整体布局)----tabs(content属性 和href属性)
    别的组件有没有href?
    toolbar属性:值是ID;
    formatter属性的三个参数:value代表当前字段的值的简单数据类型;
                            row代表当前行数据对象--串;
                            index代表当前行的索引;
    datagrid中的pagenations 分页工具;modal模态框;
    ZTree是jquery的插件;
    
    1.所有的显示数据的地方都可以异步加载;
    2.ztree的使用;
    文本框支持多行,框的大小支持自适应;
    load和reload方法;加载和重新加载都有参数;参数url代表的是服务器的资源地址,返回json数据,数据会和表单自动相对应
    表单数据回显:
时间的注册:
        时间的注册:
        创建时间转换器:类似于监听器
        DataConverter date new DataConverter();
        设置格式
        date.setPattern("时间格式");
        将转换器注册给需要时间转换的对象
        ConvertUtils.register(时间转换器对象,需要注册的对象的字节码文件);
  -1-16
javaEE包括13门规范:1.JDBC(java Database Connectivity) 数据库访问的统一途径
                   2.JDNI(java name adn directory interface) 被用于执行名字和目录服务,提供了一致的模型存取和操作企业级的资源如DNS何LDAP,本地文件系统或者应用服务器中的对象;
                   3.EJB(Enterprise JavaBean) JavaEE服务器端组件模型,设计目标与核心应用是部署分布式应用程序; 企业Bean是java的核心代码,分别是会话bean实体bean和驱动bean;
                   4.RMI(RemoteMethod Invoke) 使用序列化方式在客户端和服务器端传递数据,是一种被EJB使用的更底层的协议;
                   5.Java IDL(接口定义语言)/CORBA:公共对象请求代理结构(Common Object Request Breaker Architecture):将java与CORBA结合起来,被应用于新的应用和旧的系统结合起来;
                   6.JSP (Java Servlet Page) 可以写java代码(el和jstl)的Servlet页面
                   7.Servlet 小型的java程序;
                   8.XML(Extensible Markup Language) 共享数据 ,配置文件
                   9.JMS(Java message Service) 用于和面向消息的中间软件进行通信的应用程序接口,支持点对点的域和发布/订阅类型的域,还有:经过认可的消息传递,事务性消息传递,一致性消息和具有持久性的订阅者的支持.还提供新应用与旧系统集成的方式;
                   10.JTA(Java Transaction Architecture) 访问各种事务监控,主要应用于分布式;
                   11.JTS(Java Transaction Service) 是CORBA OTS事务监控的基本实现,规定了事务管理器的实现方式,该事务管理器是在高层支持Java Transaction API 规范,并在较底层实现OMG OTS specification 的java 映像;
                   12.Java Mail    提供了一套邮件服务器的抽象类,不仅支持SMTP服务器也支持IMAP服务器
                   13.JAF (JavaBean Actication Framework) JavaMail利用JAF来处理MIME编码的邮件附件,MEMI的字节流可以被转换为对象,或者转换自Java对象  (序列化   哈哈哈哈) 大多数应用是不需要直接使用的;



监听器:javaWeb中有8中监听器;

应用场景:javaSE GUI编程,Android手机开发 JAVEE的一些旁门需求
监听器术语:
            1.事件源:被监听的对象,目标的对象::::::::获取
            getServletContext()
            getResouce()
            2.监听器对象:用于监听事件源的对象;;;;;;;;;感觉是要创建导包获取?
            3.注册:将监听器对象注册给事件源,当事件源的状态改变时发生会执行监听器对象:类似于时间的注册
            4.事件:被监听对象的行为,会触发
            5.事件对象:怎么获得
            !!!!!!事件对象可以获取到事件源对象;
    结论:监听器专门用来处理事件源产生的事件;

监听器都是接口 方法两个:Initialized(ServletContextEvent sce)  监听器的初始化
                            初始化需要的数据,加载文件
                        Destoryed(ServletContextEvent sce)  监听器的销毁
sessionlistener session创建次数估计访问人数;
Bean的监听器在实现类的时候就已经注册了所以不需要再配置文件中注册,必须实现序列化接口否则会抛异常和监听器接口;
    Bean在session作用于的钝化:服务器正常关闭时将数据写入到文件;
                         活化:将指定文件加载到作用于;
钝化和活化运用于服务器的优化:  加缓存,分布式;
钝化和活化时机是由服务器配置的,可以通过手动设置改变,通过设置maxIdleSwap的分钟数;
指定钝化时间_在META-INF文件夹下创建Context.xml
<Context>
 <!-- maxIdleSwap:session中的对象多长时间不使用就钝化 -->
 <!-- directory:钝化后的对象的文件写到磁盘的哪个目录下  配置钝化的对象文件在work/catalina/localhost/钝化文件 -->
 <Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">
  <Store className="org.apache.catalina.session.FileStore" directory="itcast205" />
 </Manager>
</Context>

复习对象的序列化:利用ObjectOutputStream和ObjectInputStream实现对象的序列化,必须实现序列化接口;


常见监听器:前者监视创建和销毁后者监视属性变化,需要在xml中配置
ServletContext:ServletContextListener和ServletContextAttributeListener!!!!!!常用功能:初始化对象数据(数据库-连接池等) 加载框架配置文件,任务调度
HttpSession:HttpSessionListener和HttpSessionAttributeListener
ServletRequest:ServletRequestListener和ServletRequestAttributeListener


邮箱服务器:
反向代理服务器和缓存服务器 查一下
SMTP协议-发邮件协议:端口号:25;
                    全称是Simple Mail Transfer Protocol(简单邮件传输协议),他定义了邮件客户端与SMTP之间\以及两台SMTP之间的通讯规则
POP/POP3协议-邮件接收协议:端口号是110
                    全称是Post Office Protocol(邮局协议),定义了客户端与POP3服务器之间的通讯规则;

邮件的发送与接收:客户端到SMTP服务器,再传输到另一台SMTP服务器,存储到服务器本地,由POP3服务器取出,经过POP3/IMAP(???????????????????)传到客户端;

    配置文件--创建验证器--Session 代表与邮箱服务器会话对象(参数看一下)-- 创建邮件--配置邮件-- --发送邮件
    记得配置XML;
在以后的变成中谨记,用什么封装就用什么解开,除非可以互通;
  -1-17
过滤器 Fileter:本质特殊的Servlet 运行在服务器端的程序,先于附加的Servlet和Jsp运行,实现对请求的规律功能;
                对Servlet容器调用Servlet的过程进行拦截;
    应用:解决全站乱码,自动登录,屏蔽非法文字,进行响应数据的压缩;
    生命周期:创建:服务器正常启动
             工作:服务器接收到请求
             销毁:服务器正常关闭
    直接访问才会执行,并不是访问一次执行一次;

过程:1.用户登录,访问servlet,在数据库中查询,在service中处理返回给servlet
            登录成功:将用户信息保存在session中;
                     如果用户勾选自动登录,用cookie记录信息 格式是用户名@密码;
                    重定向到首页
            登录不成功提示错误信息,跳转到登录页面重新登录;

     2.第二次登录:发送浏览器缓存的cookie信息:
        注意所用的request是转型之后封装起来的request;
        过滤器: 如果已经登录 不进行自动登录
                如果浏览器没有自动登录cookie信息,不进行自动登录
                如果cookie信息有误,不进行自动登录
                用户没有登录,浏览器记录正确的Cookie 将完成登录(session记录状态)


枚举的格式: enum Color{BLUE,RED;}  你家的类才有括号 记住了!!!
    一般用来静态的表示一些类型较少的值;

1.5 新特性:    泛型 自动封装箱 注解 静态倒入即静态方法不需要写大类名
web工程下的两个文件夹
META-INF文件夹:主要用来存放一些信息
MANIFEST.MF文件 是在将java代码打包的时候出现的文件,里面的信息表明了使用的Manifest的版本和使用打包的JDK的版本;

Control character in cookie value or attribute
为什么cookie在存的时候要用url编码?因为cookie参照的是ASCII编码;
因为cookie不支持中文,所以在设置cookie的时候用URL编码 取出cooki的时候解码;

  -1-19
    注解:具有一定功能的语法形式
        耦合性大不利于维护,但开发成本低,效率高
    简介:
        Annotation注解,代码级别的说明,JDK1.5的新特性,与类,接口,枚举是同一个层次;
    作用:
        1.使得编译器能够实现基本的便已检查
        2.对代码进行分析,从而达到取代xml的目的;
        3.辅助生成帮助文档对应的内容;
JDK提供的注解:
        1.@Deprecated 表示被修饰的方法已经过时.(安全问题或者是被新的API取代)
        2.@override JDK5.0表示复写父类的方法,JDK6.0还可以表示实现接口的方法
        3.@SuppressWarnings 表示警告,会被编译器忽略
            deprecation  过时
            rawtypes     忽略类型安全
            unused       未使用
            unchecked    忽略安全检查
            null           忽略空指针
            all             忽略所有
自定义注解:使用@inteface关键字;
            内部格式:修饰符  返回值类型  属性名() default(可以省略) 值;
                注解中的属性和方法的默认修饰符是public abstract;
                返回值类型可以是String 基本类型 Class 注解 枚举 以及以上任意一个类型的数组;
注解使用的注意事项:@注解可以没有属性,  但是有的话必须用小括号包住;
                   @属性的格式:键值对的形式,用逗号隔开
                   @如果属性名为value,且只有一个属性,value可以省略;
                   @属性的类型为数组的时候设置的格式是:{1,2,3};
                   @属性为数组的话,数组中只有一个值,大括号可以省略;
                   @一个对象上注解只能使用一次不能重复;
!!只有用JDK提供的元注解修饰之后才能通过 java.lang.reflect.AnnotatedElement接口中的方法获取到注解;
                    类似于反射中的方法:
元注解:用于修饰注解的注解;
        JDK提供的四种注解:
                @Retention用于确定被修饰的自定义注解的生命周期;
                    RetentionPolicy.SOURCE  被修饰的注解只能出现在 源码 字节码中没有 提供给编译器使用
                                   .Class             源码和字节码中                  JVM使用
                                   .RUNTIME            源码  字节码 运行内存中        取代XML配置

                @Target 确定被修饰注解的使用位置
                    ElementType.TYPE  修饰类 接口
                               .CONSTRUCTOR 修饰构造方法
                               .METHOD    修饰方法
                               .FIELD     修饰字段;
                @Documented 使用javaDoc生成API文档时是否包含此注解
                @Inherited  父类被注解修饰,子类是否继承(接口应该也一样的)
    解析注解的过程就是获得使用注解的参数的过程
接口中没有的方法,动态代理是无法增强的;
Proxy:静态方法newPorxyInstance(loader,interfacs,h);
        参数:
            loader:当前类.class,getClassLoader();
            //interfaces:代理类实现的所有的接口,不能使用getclass.getinterfaces() 只能取到自己的;
            //new class[]{接口.class} 这是自己一个一个找的吗??
动态代理与静态代理的区别:接口中没有方法不能实现
            动态代理:接口下所有的实现类的对象
                代理对象:手动创建
                被代理对象:HttpServletRequest 对象
            动态代理使用反射技术,扩展性强,但是执行效率低;
            静态代理:接口现所有的实现类
                代理类:新建一个类 实现接口 增强方法
                被代理类:HttpServletRequest
                适配器可以减轻方法实现的负担;(只实现增强的)
类加载器:将字节码文件加载到运行时中,并形成字节码对象
    反射和动态代理操作的都是字节码对象;
    通过类加载器获得类加载路径(字节码文件存在的文件夹路径 web项目中是在web-inf/classes)下的文件
读取文件路径
方法1:相对于classes文件夹
ClassLoader loder=Class对象.getClassLoader() 获得类加载器
Source source=loder.getResource(资源名称); 获得加载资源
source.getPath()  带盘符的绝对路径
方法2:相对于web应用的
ServltContext读取文件
this.getServletContext().getRealPath();
使用getResource使用相对地址;


  -01-20
分类:图形化界面和服务器版
     内核和发行版本
linux的目录:
            bin  二进制可执行文件
            sbin 存放二进制可执行文件 只有root访问
            etc  存放系统配置文件
            usr  共享文件
            home 用户文件根目录
            root 最高权限用户单独的文件夹
            监视器和过滤器;
            
在linux中安装mysql时会出现mysql登录时不能通过mysql.socket连接的问题, 报错提示是不能通过'/tmp/mysql.sock'连接到服务器,而PHP的标准配置是通过'/tmp/mysql.sock'连接的;一些安装方法将这个文件放到/var/lib/mysql.sock
        通过修改/etc/mysql.cnf  改成socket=/var/lib/mysql.sock  再加上[mysql]  socket=/tmp/mysql.sock  还可以修改php.ini中的配置来使用php的其他mysql.sock连接
        或者是ln -s /var/lib/mysql.sock/tmp/mysql.sock
linux的软件安装:
    修改linux编码 etc/sysconfig/i18n(国际化库 编码和语言) ;
    linux的防火墙的端口必须手动开放;
    /sbin/iptables -I INPUT -p tcp --dport 端口号 -j ACCEPT
    /etc/rc.d/init.d/iptables save ---将修改永久保存到防火墙中
    lixux中可以安装官网的wine来运行exe文件,一般是寻找后缀问sh的文件来运行;
    执行sh文件时,需要看是否有文件的执行权,可以手动添加执行权 chmod u+x 文件名  然后./执行文件
    数据库乱码问题:修改编码;    
Redis:内存数据库;
        存储的是类似于map的键值对表:键是String(最好不要超过1024个字节) 值有String(最长是512M),map(被json取代),list(不存在创建,键对应的所有值都不存在,那么键也将被删除),set,hashset;
    String :存取时String和其他的用的方法不一样;其他的需要加前缀h,多个加m;
    List:存取list时,前缀头是l 尾是r  增删是push 查看是range 删除是pop就是弹栈; 获取格式是llen(同其他); 整数表示从头开始 负数表示从尾开始;删除某种元素lrem;
        设置某个索引的元素 使用的是lset;
    Set:什么叫操作的时间复杂度为O(1);  长度使用前缀加card;
    可以追踪一些唯一性的数据,还有就是服务端的聚合操作整合数据;
    服务器端完成多个sets之间的聚合计算操作(unions\intersections\differences),效率高,节省网络IO开销;
        前缀是s 增删是add和rem;
        获取所有的成员:smember;判断是否存在:sismember set 元素名称;返回值是0(元素不存在或者set本身就不存在)或1;
        sdiff set1 set2   返回前者和后者的差,与顺序有关;
        sinter set1 set2 set3  返回交集;
        sunion set1 set2 set3 返回并集;
    Sorted-Set:每一个成员都会有一个分数与之相关联;
    前缀是Z 增加是zadd 集合 分数 成员; 获得是zscore 集合 成员;
    (包括索引前后)范围查询:从小到大zrange 集合 索引范围 [withscores]
             从大到小zrevrange 集合 索引范围(包含两端)[withscores]
             zremrangebyrank 集合 索引范围 按照排名范围删除元素 默认从小到大
             zremrangebyscore 集合 范围  按照分数删除;
             limit的用法类似于数据库查询中的limit;
    key的通用操作:keys 正则
                  del keys
                  exists key
                  rename key newkey
                  expire key 设置过期时间
                  ttl key 获取该key所剩的时间;
                  type key 返回类型(五大类型)
启动多个redis的方法:
    1.直接在启动的时候修改端口号;
    2.拷贝redis的目录 然后编写配置文件修改端口号,适合部署集群;
jedis是java    Redis 使用hava语言操作redis数据库;主流是jedis和Redisson,托管在github上;
        Redis的命令和Jedis的命令是一样的,String在Redis中是二进制安全的,存入的是二进制字节流,存入的是什么,取出来就是什么,保存的时候没有编码;
redis的持久化:
    1.dump文件的rdb方式:固定时间检查,持久化到dump文件中
    2.AOF基于语句追加,全部存到一个log文件中,服务器重启时读取效率极低;
Redis的集群默认分配16384个哈希槽供键存储,内部通过redisObject来存储
redis使用建议:
    1.关闭快照
    2.关闭虚拟内存功能
    3.设置maxmemory选项,当物理内存达到一定程度开始拒绝读写,很好的保护服务器
    4.查看slowlog get
    5.压缩内存:默认使用ziplist
    6.redis所在的机器的物理内存不要超过实际内存的3/5;
    
  -02-06
    1.增加了加密
    2.发送邮件字符串拼接
    3.发送邮件工具类使用外网发送邮件时: 账号和授权码
    4.页面在重新找服务器要的资源,如果涉及地址要写绝对地址
    5.增加了内存数据库;
    6.加入购物车,所有的数据都要封装对象
    7.涉及事务,必须要用ThreadLocal;看下那个工具了;
    8.支付的时候 客户端必须重定向到第三方支付平台,不能跳转,并且比较的是秘钥生成的hmac码;
    9.曾与层之间的解耦,使用配置文件,看下xpath解析字符串;
    10.使用pageBean的时候一定要把list加到属性中;
    11:使用bean的时候一定要将内部的数据全部封装起来;
    12.将项目发布之后,配置文件会出现在web-info的class文件下;
  .01.23
文件上传需要注意的几个问题:
        1.需要把文件放在用户直接访问不到的地方;(服务器的安全性)
        获得的文件需要处理路径,为了防止上传的时候文件路径报错;
        使用一个文件名的工具类处理文件路径;
        2.使用UUID保证文件名的唯一性防止覆盖
        3.避免同一个文件夹中的文件过多;(文件夹过多怎么办?)
        4.限制上传文件的大小(核心类中的api);
        5.用户没有上传文件 一个判空的问题
        6.临时文件
            有一个默认是10KB大小的缓存,如果上传的文件超过10KB的话 用磁盘缓存
            默认的缓存目录是系统的临时目录; 可以进行更改
            如果自己用IO实现文件上传需要在关闭流之后进行临时文件的清理;
        7.中文上传乱码问题;
  -01-28
命令模式:按框架开发标准进行拓展和填充;
框架:重复性的代码的封装;
    MVC三层架构和Struts2:
        表现层:M model V view C control  Struts2是表现层的框架
        业务层:service
        持久层:dao data access object  Hibernate 处理持久层的框架
    Struts2的核心控制器是一个过滤器;
    获取请求路径:request.getServletPath();
Struts2==>WEB层框架:
        优势:1.易于测试,降低耦合性
             2.整合了一些以前需要手动的功能:validate验证,表单回显,防止表单重复提交,自动封装表单参数;
             //===============================================================================
             3.表达语言方面 整合了OGNL(object Graph NavigationLanguage)对象图形导航语言;缩写
                OGNL的功能
                    1.支持java对象方法的调用
                    2.支持类静态方法的调用和值得访问;表达式的格式为@全包名@方法名(参数列表)或者值名
                    3.支持复制操作和表达式串联
                    4.访问OGNL上下文对象和ActionContext===意味着可以访问servlet对象
                    5.操作集合对象
                OGNL的三要素:
                    1.表达式:要做什么
                    2.根对象(Root):对谁以及谁的关联对象操作
                    3.Context对象:操作对象的上下文环境,是一个Map类型的对象,访问上下文中的对象的格式是:"#对象名称";
                Ognl.getvalue(描述,上下文对象,上下文对象.getRoot);
                如果在对象域中设置了对象 第三个参数就是那个对象,否则为null,但是依旧可以运行这个方法;
            
            //================================================================================
             4.绑定值到视图技术,使用"valueStack"技术.
             5.类型转换,使用OGNL进行转换;
             6.基于Spring AOP思想的拦截器机制,更容易拓展;
             7.一次请求一个Action 线程安全,但是高并发需要消耗大量资源
        基本配置:配置文件的加载顺序,如果重名,后者覆盖前者; xml在服务器启动时就会被加载;
            default.properties(用于配置struts常量)——struts-default.xml(struts提供的默认配置文件,大部分功能都在此配置)——plugins配置(插件核心配置文件,整合其他框架的工具)——struts.xml(用户自定义核心配置文件)——struts.properties(用于自定义struts常量配置文件)——web.xml(也可以配置常量)        
                前三个文件用户不进行修改!
        常见的struts常量:
            1.struts.i18n.encoding=UTF-8;       编码   i18n在linux编码的设置中见过
            2.struts.objectFactory=spring;      整合Spring所需要的配置 默认注释掉了
            3.struts默认使用文件上传解析工具:apache-commons-fileupload
                struts.multipart.parser=jakarta
                3.1 临时文件保存位置
                        struts.multipart.saveDir=
                3.2 上传文件最大大小,默认值:2M,单位字节
                        struts.multipart.maxSize.
            4..用于设置action请求路径扩展名。默认:action或空。多个值使用逗号分隔
                    struts.action.extension=action,,
                    例如:/hello/userAction  或  /hello/userAction.action
            5..确定是否使用动态方法调用。默认关闭的。
                    struts.enable.DynamicMethodInvocation = false
                动态调用格式,xml文件中普通配置,地址栏方法和名称中间加!
            6.设置开发模式,默认关闭。如果设置true:将提供更多提示信息,自动加载文件。
                    struts.devMode = false
                6.1 自动重新加载国际化资源文件。
                    struts.i18n.reload = true
                6.2 自动冲洗加载xml配置文件。例如:struts.xml。但不会自动加载action类。
                            struts.configuration.xml.reload = true
            7.设置struts标签主题,默认值:xhtml。取值:simple。
                struts.ui.theme=xhtml
                开发中常用simple。xhtml存在默认布局,开发中布局使用美工提供页面,布局自定义。
        struts.xml详解:顺序不能倒
            1.<constant name="struts 提供的固定常量名称,从default.properties文件获得" value=""> 配置常量
            2.<package name="给当前包进行唯一命名,虚拟包" namespace
            ="action访问路径前缀" extends="继承的其他包名" abstract="是否抽象,默认true 表示没有action实现具体的功能">
            <action name="action的名称" class="全包名" method="方法,默认值execute"></action>
            <result name="方法的返回值" type="结果集类型 dispatcher 转发 默认值 redirect 重定向  redirectAction 重定向到另一个Action stream 流的方式发送到浏览器 用于文件下载  chain 链 从一个action到另一个action">jsp路径</result>
            </package>
            3.<include file="文件名">将多个配置文件组合成一个,struts.xml的入口配置文件,共同用于存放通用模块.
        action访问:
            通配符:路径使用(*_*_*) 分别表示 action的名称 方法名和返回值的名称;
            访问路径:默认访问一个action时,将依次从最小路径向上获取action
        action类:1.普通类 POJO
                 2.实现Action接口
                 3.继承ActionSupport类
        action中的方法:
                 1.必须是public
                 2.建议有返回值,类型必须为String,如果没有的话 使用 return "none";
                 3.名称自定义,没有参数,抛大异常,非静态;
        访问ServletAPI:完全解耦.只能操作request,session和application三个作用域;
                    使用ActionContext 工具类
                    ActionContext.getContext();
        操作servlet对象:ServletActionContext 工具类 获得需要servlet对象
                    都是静态方法;
        通过实现接口进行struts注入,实现接口后,重写方法进行对象的赋值;
        struts2的执行过程:请求先进入StrutsPrepareAndExecuteFilter过滤器,然后由一个叫ActionMapping分析请求信息,分析之后反馈给过滤器,过滤器创建一个ActionProxy代理对象去执行本次请求要走的流程,具体流程从ConfigManager获取,而ConfigManager从struts.xml获取配置信息,代理类将任务委托给一个叫ActionInvocation的代理,在执行的时候会经过框架中全部的拦截器,进行拦截器的预处理,拦截器就是框架对一些常用功能的封装,全部经过后,找到了Action 返回一个字符串,跳转到JSP,然后JSP将重新倒序经过拦截器进行拦截器的后处理,(类似调用方法返回的路径)最后封装成一次响应;
    拦截器原理:AOP思想
               责任链模式:
                    过滤器中的放行方法;
    配置过滤器时,因为struts2的过滤器没有放行方法,所以应该放在所有过滤器的最后;
  -02-20
    参数的封装:
        属性驱动:
            提供set方法:如果数据过多抽取javaBean;
            通表达式直接封装:表单中name属性的格式:name="javaBean.属性名";,提供get和set,自动封装    
        模型驱动:Action实现ModelDriven接口,重写getModel()方法,返回一个数据模型对象;    
        指定的实体必须手动实例化;只能制定一个模型;
==================================================================================    
        1.只要将参数在action内私有化,提供get和set方法就可以根据字段名称自动获取并封装;
        2.struts会自动转换基本类型,包装类和date类型(要求格式yyyy-MM-dd或后面加HH:mm:ss);
        3.容器数据封装
        Map:    JSP页面:name属性格式:name="userMap['u001'].userName";
               action类:必须提供私有的Map和get和set方法;
        List:   JSP页面: name属性格式:name="userList[0].userName";
               action类:提供私有的List和构造方法
        Array:  JSP页面:正常;
               action类:request的方法获取;
    ==================================================================================
    统一可以通过实现接口或者继承父类自定义的部分:
        1.字符串和指定类型之间的转换;
            提交表单是正向转换,回显是反向转换;
            指定类型:8大基本类型和包装类,Date,Map,List,Array
            支持自定义类型转换!!!!!!
        2.注册转换器
            局部:配置文件在同包下,内容是属性=转换器
            全局:配置文件在src下,内容是类=转换器
        3.数据校验
            手动校验:创建的Action继承ActionSupport类然后重写validate方法,方法名必须是validate加上大写的校验方法名(底层拦截器先执行);
            xml配置校验:      
        4.自定义拦截器
            默认拦截器:栈
            可以自定义并将之指定为默认的拦截器,使用自定义会覆盖框架提供的默认拦截器;
    访问servlet的API:
        1.ActionContext类 :可以获得Servlet API的域对象,无法直接获得API对象;
        2.实现接口直接访问Servlet API对象;
            通过实现注入对象的接口(接口中有设置对象的方法,),实现获取注入对象的值;(框架解耦获得其他对象的基本思想)
                例如:ServletRequestAware,这类接口的后缀是Aware;
        3.ServletActionContext类中的静态方法获取;
    Result的配置:
        局部配置:正常配置在Action内部就可以实现
        全局配置:在同一个package下配置的Action都执行这个result,在action外,package内;    
        <result-type>:chain--处理action链,被跳转的action依然能获取上个页面的值
                      dispatcher--默认值,转发,可以获取到request中的值;
                      redirect--重定向到一个URL,request中的信息丢失;   
                      redirectAction--重定向到一个Action,request中的信息丢失;
                      stream--向浏览器发送Imputstream对象,通常用来处理文件下载和ajax数据;
    Action:每个Action都有一个ActionContext上下文对象;
        生命周期:
            创建:每次访问都会创建Action对象;而Servlet对象只在初次访问的时候创建一个;
            销毁:访问结束就会Action销毁;
        Action对象由struts2框架创建,servlet是tomocat服务器框架创建;    
    ActionContext actionContext=ActionContext.getContext();
        获得的是域对象功能==容器;
        
//    LAMP:LINUX  Apache Mysql PHP(PHP开发的一套架构)

//Ctrl shift R 搜索资源文件
//Ctrl shift T 搜索源码中的类
//隐藏的标签还是挺有用的
  -02-23
    ☆ValueStack值栈:是一个接口,通常使用的是他的实现类OgnlValueStack;一个请求,建立一个action的同时创建一个ActionContext,在中间创建一个OgnlValueStack的对象,获得Map对象(有值栈的引用)传入到ActionContext的构造方法创建ActionContext,生命周期和action是相同的生命周期和action是相同的;                    ☆OGNL会将请求的参数封装成对象存储到值栈中,然后用表达式读取;
    ☆//CompoundRoot root:存储了action对象,是OgnlContext的Root对象;继承了ArrayList实现了压栈和出栈功能,被称为对象栈,root栈,集合类型;
    ☆Context:OgnlContext上下文,一个map结构,存储了servlet的一些引用:parameters,request,session,applocation, attr             检索顺数据的序是从小到大;还存有值栈的引用;
    //ActionContext和ValueStack互相有引用,前者在获取ServletAPI的时候会依赖后者;
    !!!!!先获得ActionContext对象 然后获得值栈(就相当于一个大的域)  可以存值取值 在页面取的时候是利用OGNL 表达式;
    ☆EL特殊字符的使用:
    警号   #request(域).key
    百分号:强制解析OGNL    %{#request.key}
           强制不解析OGNL  %{'#request.key'}
    $  用于struts的配置文件中使用.xml文件或者是属性文件
    //向栈中保存数据
        1.向root栈保存数据
            手动向Root栈保存数据:
            push();pop();peek();set();   
            自动向Root栈保存数据(struts框架自动保存):
            1)自动向栈顶压入当前Action
            2)自动压入Model;
        2.向context栈保存数据
        手动向Context中保存数据:
        
        自动向Context中保存数据:
        对象:request,response,servletontext;
        域数据:request,aplocation,session,attr,paramters;
        ValueStack对象封装的保存数据的方法:
            push();pop();peek();set();
        标志位思想:使用一个标识符,保证使用同一个对象;
        
    取出root栈顶的数据:<s:property value="[0].top">    
    取出context中的值需要加#,由key取value
    为什么el表达式也可以取栈内的值?
        el是从request域中取值;
    经常看到方法A和方法A1同名 前者有返回值(参数)--后者没有返回值(参数),一般使用后者调用前者;利于维护,解耦;
  -02-24
    SOA 面向服务架构;--模块化手机!
    IOC在struts2中的体现:Action对象的创建由struts框架去创建;
    AOP在struts2中的实现:拦截器的实现;
    拦截器(Intercepter):在AOP(Aspect-Oriented Programming)中由拦截链(Intercepter Chain)在struts2中是拦截栈(    Intercpter  Stack),按顺序排列好的,在Action前后执行的的代码;可以实现拦截和增强功能;
    
    拦截器和过滤器在使用的时候一定要加上使用的目录,或者配置跳过方法;
    
    自定义拦截器的实现:
            1.实现Intercepter接口
            2.继承AbstractIntercepter类,
            ,继承methodFilterIntercepter类;
    配置拦截器:
            <interceptors>
                <interceptor name="拦截器名称" class="全包名"></interceptor>
                <interceptor-stack name="myStack">
                    <interceptor-ref name="defaultStack"></interceptor-ref>
                    <interceptor-ref name="拦截器名称"></interceptor-ref>
                </interceptor-stack>
            </interceptors>
    Struts2de 标签库:
        额外标签:<s:action------> 显示action中的属性的信息;
        普通标签:在页面生成时,控制执行流程
            控制标签:完成逻辑控制,做集合的操作;
                <s:if test=""></s:if>
                <s:else></s:else>
                <s:elseif test=""></s:elseif>
                <s:iterator value="" var=""> </s:iterator>
            数据标签:显示后台数据和进行数据访问;
            <s:property escape="是否忽略HTML代码" default="如果要输出的值为null 显示default属性的指定值" value="指定需要输出的属性值,如果没有该属性值,则默认输出值栈顶的值"></s:property>
            <s:a action="指定的超链接Action地址" href="超链接地址" namespace="指定的Action地址" id="指定ID" method="需要调用的指定Action的方法" ></s:a>
            <s:debug id="一般不适用">弹出debug信息</s:debug>
            <s:param  name="" value="" suppressEmptyParameters="" > </s:param>
        UI标签:使用html文件显示数据;
            主题:
                simple:UI标签只生成最基本的元素没有附加功能
                xhtml:默认主题,扩展了simple,提供了布局,<label>显示名称,以及验证框架和国际化框架的集成;
                css_xhtml:该主题是对xhtml的拓展,添加了对CSS的支持和控制;
                Ajax :继承了xhtml,提供Ajax支持;
            配置:<constant name="stauts.ui.theme" value="simple"/>
            分类:
                Form-tags:生成html的表单元素;
                    类似于HTML便签,功能更加强大
                    公用属性:
                    <s:form entype="multipart/form-data">  action中的地址不需要后缀;
                    <s:submit>与form一起使用;
                    
                优化:1:对样式优化
                     2:对数据回显优化
                NotForm-tags:生成html的div标签以及Action中的                
                Ajax-tags:提供Ajax支持;    
        标签支持回显!!
  -02-26  Spring框架  
SpringBoot:
    基于约定的框架!按照框架之间默认的约定进行配置;
    三层架构:
        WEB层:Spring的MVC架构
        业务层:Bean管理(IOC)
        持久层:Spring的JDBC模板:ORM用于整合其他的持久层框架
    Spring:一个分层的JavaSE/EEfull-stack(一站式)轻量级开元框架; 是对EJB这个重量级框架的的替代
        优势:可以负责所有对象的创建和依赖关系维护
        AOP:方便进行权限拦截和运行监控,底层是动态代理
        声明式事务的支持:通过配置事务管理(配置一次就可以指定service层中的所有的方法自动进行实务控制)
        测试方便:通过注解测试程序,Spring-test.jar;
        利于框架的集成;
        提供工具模板,对框架的复杂API进行简化;
    Spring的环境搭建:
        1.导入jar包 核心容器的四个包:beans core context expression
        2.Spring内置对logging进行整合;
        Logging内部又对log4j进行了整合,如果logging内部没有找到log4j,那就使用自己的日志技术;
    Spring中的两个工厂:
        1.ApplicationContext:在加载配置文件的时候就会创建对象;--饿汉模式
            ClassPathXmlApplicationContext: 加载类路径下的Spring的配置文件;
            FileSystemXmlApplicationContext:
            加载本地磁盘下Spring的配置文件;
        2.BeanFactory:在getBean的时候才会创建对象;--懒汉式
    Spring的相关配置:
        1.id:Bean的名称,必须唯一,命名必须满足xml的规范,不能出现特殊符号
        可以相同不会报错,但是会覆盖
        2.name:Bean的名称,没有采用ID约束的,name可以当做约束,可以出现特殊字符,当做ID使用
        不能配多个相同的name,会运行报错
        3.scope:
            singleton:默认值,单例的--加载配置文件的时候创建
            service和dao这样的Bean全部配置成私有属性;
            prototype:多例的--使用bean的时候创建
            request:创建的Bean存储到request域中
            session:创建的Bean存储到session域中
            globalSession:应用在Protlet环境???? 如果没有Protlet环境,相当于session;
        4.Bean的生命周期配置:标签上有init-method和destory-method分表表示初始化和销毁时执行的方法;销毁的方法想要执行必须是单例的Bean而且在工厂关闭的时候,Bean才会被销毁;                    
    Spring生成Bean的三种方式:
        1.无参构造方法的方式:
            正常的方式;
        2.静态工厂实例化:
            提供一个工厂类,实现创建Bean的静态方法;在配置文件中使用factory-method配置方法;
        3.实例工厂实例化Bean
            配置Bean工厂实例创建的配置文件,然后在创建Bean的时候使用factory-Bean选择已经创建好实例的工厂,然后使用factory-method选择创建的方法;
凡是需要框架封装的必须要加set方法;     
    Spring 的复杂数据注入:
        类型怎么写 内部怎么写;
    Spring的Bean的属性注入:
        1.构造方法注入
        <constructor-arg name="" value="">
        2.set方法注入
        <property name="" value="">
    Spring的属性注入:Bean的注入:
        类似于Spring的Bean的属性注入
        <Property name="名称" ref="要注入的对象的名称">
        /<Property p:name="" p:名称-ref="要注入的对象的名称">
    p----名称空间p的属性注入的方式:Spring2.x版本后提供的方式
        第一步:引入p名称空间,照抄beans
        第二步:使用  普通属性: p:属性名称=""
                     对象类型属性: p:属性名称-ref=""
                     属性注入的简化!
    SpEL的方式的属性注入:Spring3.x 版本后提供的方式
        SpEL:Spring Expression Language
        语法:#{SpEl} 配置文件中对象值的引用
        通过表达式可以在配置文件中取值;整个配置文件都能获取;
    Spring的分配置文件的开发
        一种:创建工厂的时候加载多个配置文件:将多个配置文件传入到参数中即可;
        二种:在一个配置文件中包含另一个配置文件
  -02-27
    Spring的注解开发:组件扫描(类上注解:可以直接使用属性注入的注解)
    注解取代xml配置文件,注解的使用前提是添加命名空间,
    <context:componet-scan base-package="要扫描的包名">
        此配置的作用是向Spring容器注册,这样才能识别注解
    Spring的Bean管理中常用的注解:
        1.@component:组件.(作用在类上);
            三个此组件的衍生注解:语义化注解
                @Controller:web         层
                @service:业务层
                @Repository(储藏室,智囊团):持久层====数据交互
        2.属性注入的注解,使用注解的注入方式,可以不提供set方法
            @Value:用于注入普通类型
            @AutoWired:自动装配:
                默认按类型进行装配.
                按名称注入:
                    @Qualifier:强制使用名称注入
            @Resource相当于:
                AutoWired和@Qualifier一起使用;
        3.Bean的作用范围的
        类似于scope属性:
            @singleton:单利
            @prototype:多例
        4.Bean的生命周期的配置
        @PostConstruct :相当于init_method
        @preDestory    :相当于destory-method    单例需要手动销毁
    注解和xml配置之间的比较:
                                        基于XML配置         基于注解配置
                            Bean定义    <bean id  class>     @Component衍生的三个
                                                             @Repository:持久层
                                                             @Service:业务层
                                                             @Controller:web层
                            Bean名称    通过唯一标示的ID     @Component("名称")
                                        或者名称指定                            
                            Bean注入     通过<property>       @AutoWired按类型注入
                                        或者p命名空间注入     或者是@Qualifier按名称注入    
                            生命周期和  init-method,         @PostConstruct初始化
                            作用范围    destory-method       @PreDestory 销毁
                                        和scope属性             @Scope 设置作用范围
                            适合场景    Bean来自第三方        Bean由自己开发
        使用最多的是xml配置Bean,清晰,解耦 注解负责注入属性AOP,方便但是耦合
        
    OOP(面向对象编程)-AOP(面向切面编程)-SOA(面向服务架构)    
    AOP(Aspect Oriented Programming):面向切面编程;隔离各个逻辑业务,降低耦合性,提高重用性和开发效率;
        不修改源码的情况下:AOP可以进行权限校验,日志记录,性能监控,事务控制;
    AOP底层:默认是cglib的机制
        两种代理机制:
            JDK的动态代理:针对实现了接口的类产生代理
                创建被增强对象,创建代理
            Cglib的动态代理:针对没有实现接口的类产生代理,引用的是底层字节码增强的技术,生成当前类的子类对象,第三方基于子类的动态代理,被Spring集成;
                步骤:创建增强器---设置被增强为父类---设置回调(callback的子类接口)--创建目标对象的增强子类对象--调用方法;
    Spring的基于AspectJ的AOP开发
        什么是AspectJ:基于AOP模式的框架;Spring本身有自己的AOP机制,但是AspectJ的实现方式简单,Spring集成AspectJ;
        相关术语:
            1.JoinPoint(连接点):所谓连接点是真正被增强的方法,Spring支持方法类型的连接点;
            2.Pointcut(切入点):指的是我们要对那些连接点进行拦截的定义;
            //execution(方法修饰符  返回值  全包名 类名 方法名(方法的参数) )
            开发中的一些习惯====方法修饰符省略
            子包使用的两个点表示       * com.itheima.service..*.*()
            接口的任意子类               * com.itheima.service.接口+.*()  
            3.Advice(通知/增强):通知是指拦截到连接点之后做的事,分为前置通知,后置通知,异常通知,最终同志,环绕通知(切面要完成的功能)
            通知的类型:  通知中产生的数据都可以拿到;
            前置通知:before
            后置通知:after-returning
                可以传参  传切点和 一个返回值    
                如果编写返回值 必须在配置文件中配置;
            环绕通知:around  切点前后都有  相当于动态代理的invoke
                环绕通知的方法中会传入一个叫ProceedingJoinPoint的参数;
            异常抛出通知:after-throwing
            获得异常信息  是Throwable 必须在配置文件中配置
            抛出异常之后不会执行下面的代码
            最终通知:after 相当于finally 最后一定会执行
            4.Introduction(引介):一种不修改类代码的前提下的特殊通知,可以在运行期间为类动态的添加一些方法或者字段;  针对类的;
            5.Target(目标对象):代理的目标对象
            6.Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程;
            将增强和切入点结合的过程;
            Spring采用动态代理织入,而AspectJ采用编译期织入和类装载期织入;
            7.Proxy(代理):一个类被AOP织入增强后,就产生一个结果代理类
            8.Aspect(切面):是切入点和通知(引介)的结合;整个增强的整合;
    Spring使用AspectJ进行AOP开发:XML的方式
            1.确定要增强的类
            2.增强的类以及方法
            3.配置<aop-config>
                    其中要配置切入点<pointcut>和切面<aspect>两个配置,切面中指明切入点和通知;
    Spring集成JUnit:
        1.导包
        2.指定Spring的测试类
        3.指定配置文件
        3.注入要测试的对象
        @RunWith(SpringJUnit4ClassRunner.class)    
            帮助创建对象
        @ContextConfiguration("classpath:applicationContext.xml")  加载配置文件
        
  -02-28
    多例没线程,单例成员有线程,加锁,但会影响效率;
    将一些功能封装成对象使用,聚柄对象;
注解开发(AOP):
    开启自动代理,创建切面Bean
数据库模板:
    模板 JdbcTemplate:drivenManager
         c3P0: combompool
         DBCP  basicdatasource
    使用Spring内部的数据源 需要设置参数;
        
    配置的抽取:
                将配置文件抽出,使用context palceholder    属性占位  使用el表达式取出;
事务:
    平台事务管理器(数据源)======事务模板(平台事务管理器)
    声明和编程都需要               编程式需要
    
    声明式:advisor标签 用于一个增强
        根据tx配置一个advice作为增强 然后根据AOP配置
        isolation:隔离级别
        propagation:传播行为
            解决一致性问题:一个业务方法调用另一个业务方法;
            默认是required  如果不存在 就新建一个
                  required_new 如果存在,不适用本事务,重新创建一个
  -02-29
    框架整合异常:Caused by: java.lang.ClassNotFoundException: org.hibernate.engine.FilterDefinition是因为hibernate3和4的版本差异 改版本
    整合重点:
        1.struts2整合Spring    
                            struts.xml中的常量配置和action的class路径;
                            applicationContext.xml中多例的配置以及注解的注意事项;
        2.sping和hibernate整合:
                            sessionfactory的注入
                            当涉及到路径的时候加不加classpath
        如果少包,报错就是什么refresh错误
        
    全注解:
    struts注解的包是convention插件包:
    
  -03-03
版本控制(Revision control):自动记录文件内容变化的系统;
SVN(Subversion):是CVS的改良版,可以及时的对照并更新源码,记录修改过程和文件版本;
    专业名词:commit 本地添加到服务器
             checkout:服务器下载到客户端
             update:服务器覆盖更新本地
    仓库的创建:命名规范-不能有中文
    复制-修改-合并方案(默认模式):
            每个客户读取项目配置库建立一个私有的工作副本-版本库中文件和目录的本地映射.用户在工作后,各个私有的副本合并起来成为终极版本!
    开发锁定-修改-解锁方案:
            一段时间内配置看的一个文件只允许一个人修改,不适合;
    与SVN断开连接:必须执行并从文件系统中删除SVN元信息
eclips安装svn插件:
    IDE:集成开发环境;
                    5 svn仓库工程目录介绍
                        (1)trunk: 主干,放项目主体,每次修改不同的版本
                        (2)branches:分支,放项目备份版本
                        (3)tags: 一个项目不同的版本
  -02-14 将项目发布到linux上
    环境的搭建:
    将war包放到tomcat的webapps目录下,启动时会自动解压相当于已经发布了;
    war包自动解压时需要在tomcat的配置文件中的<host>标签中部署了unpackQARs="true"属性才可以;
    以下三个包都用jar方式打包,只不过扩展名不一样;
    ear包:企业级应用,通常是EJB打成ear包;
    jar包:一些class文件,声明main_class之后是可以用java命令运行的;
    war包:是一个web模块,其中需要包括WEB-INF,是可以直接运行的web模块;

    配置文件一般使用xml而不是用properties,因为前者可以描述层级关系;

    Spring:IoC(控制反转:Connection和数据库的联系 类型是由传入的数据库进行控制的)和AOP(面向切面编程:动态代理)

  -02-15    
三大框架之Hibernate:持久层的ORM框架;  
    持久层技术:JDBC,DButils,Hibernate,MyBatis,SpringJDBCTemplate,Spring JPA
        ORM:Object Ralational Mapping--对象关系映射框架;
            本质是将javaBean与表之间的关系进行抽取;
    环境的搭建:
        1.导包:
            A.数据库驱动包
            B./lib/required文件夹下所有包
            c.三个日志相关的包并且需要在src下引入配置文件
        2.配置实体与表的关系:
            创建dimain配置文件:类名.hbm.xml;引入约束,配置实体与表的关系,主键比较特殊 引用nativa生成策略;
        3.配置Hibernate的核心配置文件;hibernate.cfg.xml;引入约束;
            a.数据库连接的4个基本信息  驱动+地址+用户名+密码;
            b:其他参数;
            c:加载mapping的映射文件
    测试:1.加载配置文件
         2.获得工厂对象 sessionfactory
         3.获得会话对象
         4.数据库操作
         5.释放所有资源
    配置文件的详解    配置文件中很少有- 全部是下划线_;
        映射配置文件:类.hbm.xml
            catelog:指定库名;
            当表中的字段名和实体中的字段名一样时可以省略;
            
            主键生成策略(generator):
            字段类型(type):有java  hibernate sql三种书写方式;
            
        核心配合文件:hibernate.cfg,xml
            配置数据库语言; dialect
            显示SQL语句; show_sql
            格式化sql; format_sql
            是否根据映射关系创建表; hbm2ddl.auto create:每次执行创建新表(测试环境);
            (版本差异)                             create-drop 创建 执行完毕之后删除表;
                                                 update 如果有表直接使用,没有就创建
                                                 validate 校验表是否存在,存在执行,不存在不执行
            是否自动提交事务; autocommite  (版本差异)
            使用指定的连接池;  找provider;            
            使用的默认的连接池不提供事务控制,一条sql一个事务;                                    
    Hibernate的API操作:
            Configuration:加载配置文件的对象,hibernate的入口
            加载的src之下的properties配置文件,创建对象之后要用configure方法去加载经常使用的hibernate.cfg.xml文件;改名之后可以在方法内加参数来指定配置文件;
            SessionFactory:创建会话对象的工厂;
                特 点:1.线程安全的:支持多线程
                      2.重量级的:创建和销毁是很消耗资源的;
            Session:操作实体的对象;
            创建的方式,使用open方法和get Session()获得与线程绑定的session;
                注 意:如果使用与线程绑定的线程需要在配置文件中配置:current_session_context_class          thread
                      如果使用与线程绑定的线程,不用手动关闭;框架会关
            Transaction: 事务;
    增删改查:增加:save(对象)
             修改:update(对象)
                saveOrupdate:有ID更新 没有就插入;    
             删除:delete(对象)
             查询:查询一个实体:
            get:正常方式进入数据库查询,返回封装的实体
                load:使用代理技术,创建一个代理对象(所以类不能使用final修饰),对象的属性只有一个ID,当我们使用代理对象的时候,才会调用Hibernate查询数据库,初始化对象数据
                load可以提高执行效率;被称为延时加载;
  -02-16
    持久化类:与数据表对应的javaBean;
        规则:必须有一个空参构造方法;
             属性私有,提供get和set方法;
             属性尽量使用包装类,避免误差;
             要有一个唯一标示的OID与表中的主键想对应,不允许出现两个有相同标识的类;
             尽量不要使用final进行修饰;
         (类无法创建的异常,就找构造方法)
    延迟加载机制:使用字节码的增强技术完成的,就是产生了当前类的子类;如果持久化类使用final修饰,延迟加载机制就会失效;        
    主键需要具备: 不为空/不能重复/不能改变
        自然主键: 在业务中,某个属性符合主键的三个要求.那么该属性可以作为主键列.
        代理主键: 在业务中,不存符合以上3个条件的属性,那么就增加一个没有意义的列.作为主键.        
    主键的生成策略:
        手动指定主键:自然主键使用多
            assigned:指定的,赋值的
        自动生成主键:
            Hibernate生成:
                increament:自增
                UUID:随机字符串(使用多)
            数据库底层生成:
                identity:数据库自增;(要求数据库底层支持自增),orcle不支持
                sequence:序列方式生成;(底层支持),mysql不支持
                native  自动判断(使用多)            
    持久化对象的三种状态:
        1.瞬态:new出来的,和数据库没有关系,没有OID 数据库中没有记录,失去引用后被收回,在内存中独立存在;
        2.持久态:存在OID且有唯一性,在session的缓存中,相关联的session没有关闭,和数据库有关联,在数据库中有记录;实在事务还没有提交之前编程持久态的;
        3.脱管态:与持久态的区别只有session关闭;与瞬态的区别就是ID的值有没有; 脱管对象发生改变时,hibernate不能检测到;
        Transient  瞬态加上id就是脱管态,执行数据库方法变成持久态;
        Persistent 持久态执行delete()成为瞬态;关闭session或者清除缓存变为游离态;
        Detached   脱管态设置ID为null变为瞬态,执行方法变为持久态;
    一级缓存(session缓存,只要session不关闭,数据就不会丢失):持久态的对象可以依靠一级缓存进行数据库的自动更新;  Hibernate的内置缓存;        
        特点:调用增删改方法时,如果缓存中没有对象,就会存放到缓存中;
             调用查询方法时,再封装之前会先到缓存中去查询是否存在对象;
             session关闭,缓存消失;
        存储的是对象的引用,快照是副本,即地址;
        快照区:保证缓存中和数据库中的数据一致,类似于内存数据库;提交事务或刷新时对照并发送sql语句;    
    一般事务在service曾实现,使用的是getcurrentsession方法来获取session;会自己关闭,自己再关会报错!
    Hibernate配置隔离级别:隔离级别代号是1 2 4 8;
            islation
    二级缓存:sessionFactory级别的缓存,整个应用程序共享一个会话工厂,共享一个二级缓存;外置的,加入jar包,配置之后手动开启;
        SessionFactory的缓存:
                    内置缓存:使用一个Map用于存放配置信息,预定义HQL语句等,给框架自己使用,对外只读不能操作;
                    外置缓存:使用另一个Map,用于存放用户自定义数据.默认不开启.外置缓存hibernate只提供规范,需要第三方实现,又称为二级缓存;
        二级缓存由4部分内容构成:
                        1.类级别的缓存
                        2.集合级别缓存
                        3.时间戳缓存
                        4.查询缓存(二级缓存的第二大部分,三级缓存)
        很少被修改,不重要的数据适合放入到二级缓存中,允许出现偶尔的并发问题;
        经常被修改,不允许并发问题或者与其他的程序共享的数据不适合放入二级缓存中;
    二级缓存的提供商:
            EHCache: 可作为进程(单机)范围内的缓存, 存放数据的物理介质可以是内存或硬盘, 对 Hibernate 的查询缓存提供了支持。--支持集群。
            OpenSymphony `:可作为进程范围内的缓存, 存放数据的物理介质可以是内存或硬盘, 提供了丰富的缓存数据过期策略, 对 Hibernate 的查询缓存提供了支持
            SwarmCache: 可作为集群范围内的缓存, 但不支持 Hibernate 的查询缓存
            JBossCache:可作为集群范围内的缓存, 支持 Hibernate 的查询缓存    
    mybatis的缓存机制:
        1.一级缓存:一级缓存基于PerpetualCache的HashMapvending缓存,期储存作用于为Session,当session刷新或者关闭之后,该session中的所有的cache就清空;
        2.二级缓存:与一级缓存机制相同,默认采用的是PerpetualCache,HashMap存储,不同于其他存储作用于为Mapper(NameSspace),并且可以自定义存储源,如Ehcache,Hazelcast等;
        3.对于缓存数据更新机制,当某一作用于(一级缓存Session/二级缓存Namespaces)进行了CUD操作之后,默认该作用于下的所有Select中的缓存将被clear;
        4.MyBatis的缓存采用了delegate机制及装饰着模式设计,当put、get、remove时,其中会经过多层的delegatecache处理,其Cache类别有:BaseCache(基础缓存)、EvictionCache(排除算法缓存)
        5.一般缓存框架的数据解耦基本上都是Key-Value方式存储,MyBatis对于其key的生成采取的规则为[hashcode : checksum : mappedStementId : offset : limit : executeSql : queryParams]。
        6.对于并发读写时缓存数据的同步问题,Mybatis默认基于JDK/concurrent中的读写锁,使用ReentrantreadWriteLock的实现,从而通过所记住防止在并发Write Cache过程中线程的安全问题;
        7.开启:
        <setting name="cacheEnabled" value="true"/>
        8.设置单个sql语句禁用二级缓存
        <select id="findOrderListResultMap" resultMap="ordersUserMap" useCache="false">
        9.刷新缓存
        在同一个命名空间中,如果有其他的增删改操作之后不刷新缓存会出现脏读
        <insert id="insertUser" parameterType="cn.itcast.mybatis.po.User" flushCache="true">    
    !!!!!!!!!!!开启和配置详见预习视频hibernate_day04笔记
    并发访问策略:
        1.transactional(事务型):仅在受管理的环境中适用,提供repeatable read事务隔离级别 MySql的默认隔离级别,缓存支持事务,发生异常的时候,缓存也能够回滚;        
        2.read_write(读写型):提供Read Committed事务隔离级别,在非集群的环境中适用,适用经常被读,很少修改的数据,可以防止脏读  Orcal的默认隔离级别,更新缓存时会锁定缓存中的数据;
        3.nonstrict-read-write(非严格读写型):使用极少被修改,偶尔允许脏读的数据(两个事务同时修改数据的情况很少见),不保证缓存和数据库中的数据一致性,为缓存数据设置很短的过去时间,不会锁定缓存中的数据
        4.read-only(只读型):适合从来不会被修改的数据;数据更改操作会有一场.事务隔离级别低,并发性能高,在集群环境中也能完美运作
        
Hibernate中的表关系:     如果进行级连操作的话,全部在主控方配置,
                一对多:1.确定容器set 2.name确定对象的属性名称 3.确定本属性的外键名称
                       4.确定关系和一个对象类型    使用双向配置
                       <set name="orders" >
一对多和多对一的外键名称相同  <key column="uid"></key>
                       <one-to-many class="包名" />
                       </set>
                多对一:1.确定属性名称 2.确定自定义类型 3.外键名称
                       <many-to-one name="user" class="com.itheima.domain.User"
                        column="uid"></many-to-one>
    存在主外键关联,在添加和删除的时候都会抛出异常:
            A和B关联  一个A对应多个B
            cascade="delete A和B都不存在,delete-orhan A放弃对B外键的维护,删除B A依然存在";
            cascade="save-update"  级连保存 当保存A的时候 B也被保存(前提是双方都配置了这个属性)
            inverse="true" 双向关联  使得一的一方放弃对外键的维护交给多的一方去维护外键,减少更新表所带来的多余的SQL语句;
            all是delete和save-update的整合
            all-delete-orhan 是三者的整合;
    多对多:3个表 A    B(中间表一般是没有配置文件的)     C  
            A的配置:<set name="属性名称" table="中间表的名称">
                <key column="B表中表示A的外键" />
                <many-to-many  class="C的路径" column="c类在B表中外键的名称">
            <set>
            B的配置:和A正好相反;
            如果进行了双向维护,就要求被动的一方放弃外键维护权,单向的话不需要;
            同样,必须保存双方,如果保存一方的话需要设置级连操作,在主控方设置;
    一对一:
        分表原则:1)加速查询
                 2)语义明确
    权限表设计:经典5张表   用户  (关联表)   角色    (关联表)    职责
    
    Hibernate的检索方式: 普通的SQL 语句的执行顺序:select是最后执行的  从from开始依次执行
        1.对象图导航检索:根据已加载对象导航到关联对象;
        2.OID检索:利用主键OID进行检索; 使用get没有值返回null  使用load没有值抛异常
        3.HQL检索:
            面向对象语言查询:1.可以设定条件
                             2.投影检索,支持检索部分属性; 支持投影构造查询--即对象的构造方法作为查询目标
                             投影操作可以new Map(参数) 没有严格要求map的格式;
                             3.分页查询
                             4.支持分组查询
                             5.提供内聚函数
                             6.调用用户定义的sql函数;
                             7.支持子查询
                             8.支持动态绑定函数
            完整的语句是和SQL语句相同的 只不过from的主体变成了对象 ,检索所有的属性的时候可以将from之前的省略;
        HQL多表连接语句:
            1.交叉连接
            2.内连接:
                显示内连接:
                    (select 查询字段 from 表1  inner join 表2 on 表1.关系字段=表2.关系字段)
                    from 对象 inner join 关联属性
                隐式类连接:查询到数据之后分开封装到自己的集合中
                    from 对象 join 关联属性
                迫切内连接:查询到数据之后,封装到一个对象,自动将关联属性搞到集合中;必须使用distinct去除重复数据;(select distinct c from 类 inner join 关联属性 )
                    from 对象 inner join fetch 关联属性
            3.外连接:
                左外链接:
                select from 对象 right/left join 对象.关联属性   (关系字段等于关系字段)
                迫切左外链接:
                又外链接:    
                
        4.QBC检索(Query by Criteria):由Criteria接口-Criterion接口和Expression类组成.
                Restrictions提供了大量的静态方法返回一个Criterion对象 作为查询的条件语句;条件都可以实现 去找就好了
            DetachedCriteria:离线条件查询;可以在没有session的情况加组装条件语句传递到Dao层减少数据传输量;
        当使用projection查询多个字段的时候 使用内部的数组封装条件;     
        内部的静态方法;    
        Hibernate的抓取策略:
        1.概念:当应用程序需要在关联关系之间进行澳航的时候,获取关联对象的方法;
        2.延迟加载的分类(lazy load)也成为懒加载;
            !!类级别延迟:查询对象时是否采用加载延迟 ,一般配置在class标签
            !!关联级别延迟:查询关联对象时是否采用关联级别延迟
        1:关联级别的检索策略:
            通过已经查询到的对象去获得与之关联的集合中的对象
            在set中进行配置  一对多或多对多
                lazy:发送sql的时机
                    true:延迟加载
                    false:不延迟加载
                    extra:及其懒惰的  子查询失效
                fetch:发送sql的类型
                    select:默认值 普通语句
                    join   :迫切左外链接    lazy无效;
                    subselect:子查询语句
            <many-to-one>中配置
                lay:发送sql的时机
                    proxy:默认值;一句被关联类的class上的lazy`
                    false:不采用延迟加载
                    no-proxy不研究
                fetch:发送sql的类型
                    select:默认值 普通的
                    join:左外链接
        2.批量抓取:batch-size的设置,合并sql语句        
丢失更新:同时更新数据被覆盖;
    悲观锁:丢失更新肯定会发生,采用而数据库的锁机制.
        读锁:共享锁;
        写锁:排他锁(独占):理解为写操作的时候自己占用,如果发生死锁,会锁一整张表;
    乐观锁:丢失更新肯定不会发生;在表中[,,提供一个版本字段,用于表示记录;如果版本不一致,不允许操作;
    配置文件中配置:<version name="version"><version>

  -03-04
    数据字典表:存储基础的,不随意更改的数据;
    使用response返回数据时,action方法不能返回实际字符串;
    application/json json才能省略;
    封装model中没有字段的属性(有引用!);
    分页查询:
        使用findByCritiria
    no session 的问题解决:
        1.修改配置文件
        2.配置过滤器:opensessioninviewfilter;看源码;
  -03-06
    crm上传文件步骤:                    1.修改客户上传页面的表单的enctype为multipart/form-data
        2.提交方式为post
        3.为save方法所在的action设置私有属性:
            -上传文件名称  上传文件+名称;
            -上传文件的类型
            -上传文件  upload
        4.配置上传文件拦截器=====主要是大小和格式
        5.input是struts2中的错误处理机制;自动返回结果input!
    获得路径:getrealpath()后面需要自己加\;
  -03-07
    在el表达式中可以使用多条件;
    单例Action会锁页面,会回显用户信息;
    删除的时候,应该先去查询客户;,然后才能达到级联删除的目的;
    泛型中专业术语:
        List<User> 整体部分,成为参数化类型
        <>里面的User,成为是实际类型参数
    首先获得父类的参数化类型,然后获得实际类型参数;
  -03-09
    struts2的注解配置时,默认扫描的包是action actions struts struts2;
    配置常量改变默认扫描包;
    <context:annotation-config></context:annotation-config> 默认只扫描属性上的注解;
    !!!!如果继承父类,父类中的属性私有,get和set方法不能被继承,就自己重新写一个,调用父类的方法,使用注解执行方法;
        
    
    使用hibernate调用普通的sql语句:
        将查询结果使用setResultTransFormer();封装成一个map的list,放到域中,显示到页面
        
        
    泛型:功能不是显示,是约束添加;
        泛型擦除机制;
    Redis的session共享;
    java代码调用cmd命令:
        Runtime.getRuntime().exec(String);
        
    fastJson问题:
        1.会查询对象中所有字段并转换;
            方案:在属性上加上注解:@JSONField(serilize=false)        
        2.fastjson转换的时候会延迟加载!
            出现相同的数据的时候只转换第一个;    
            在转换的格式中,加参数(serialiazerFeature)
        json-lib工具中:JSONObject 转换对象  JSONArry转换所有的集合;支持排除不需要数据,jsonConfig的类中的setExclude(数组);
        fastJson中排除解析对象 @JSONField(serialize=false)
        private Set<Linkman> linkmans = new HashSet<Linkman>();
        String json = JSON.toJSONString(list, SerializerFeature.DisableCircularReferenceDetect);
    baseAction的抽取:
            最终获取到class类型,必须利用反射创建对象然后赋值;
    代码优化:    
        1.拆分xml文件;
        2.功能性页一般放在web-info中;通过action访问(只有type="dispatcher")
  -03-10
    maven:专家的意思,一个跨平台的项目管理工具,被用来构建和管理java项目;一个命令就可以完成构建-运行.对每个构建阶段都进行规范,非常有利于大型团队写作开发;
    一般使用maven3.3.9版本;
    项目构建阶段:
        清理-编译-测试-报告-打包-部署
            清理:clean
            编译:complie
            打包:package
    依赖管理:对项目依赖的jar包进行规范化管理;maven仓库中所有要用的jar包,可以通过配置pom.xml下载;    
    maven仓库:
        本地仓库   一般在${user.dir}/.m2/repository下;
    maven对项目的构建过程分为三套独立的生命周期
        Clean LifeCycle:在进行真正的构建之前进行一些清理工作.
        Default LifeCycle:构建的核心部分,编译,测试,打包,部署等
        Site LifeCycle:生成项目报告,站点,发布站 点;
    执行某个生命周期的某个阶段不会影响其他的生命周期;
        Group Id:包名
        Artifact Id:项目名
        Version:版本号
        jar包:和页面无交互
        war包:和页面有交互
        pom:用于打包父工程;

    命令:每个命令执行之前都会把生命周期中此命令之前的命令执行一次
        clean:清楚编译之后的文件 重新编译 (因为使用的版本不同,会报错)
        complie:将源码编译到target目录下  但是不编译test
        test:编译运行test中的源码
        package:将项目打包(类型在pom.xml中可以设置)到target文件夹
        install:安装(本质上)
    
    异常收集:无法转换为导入包类型的servlet;jar包冲突
    问题:如果你的maven/src/main/java消失了,先去library瞅瞅,完了配置KDK的路径
重点:maven创建SSH工程;
    传递依赖:maven自动添加依赖包;
    依赖调解原则:
        1.第一声明者优先原则:先添加的优先
        2.路径近者优先:路径有分级,级别越靠外的越优先
    排除依赖:在pom.xml配置文件中声明
        <exclusions>
        </exclusions>
    锁定版本:
        在配置文件中声明锁定版本的jar
        锁定不代表添加;
    
    工程的聚合和拆分
    
    nexus可以创建maven仓库并提供强大的管理功能
    ,构建搜索功能等:
        仓库种类:
            1.hosted,宿主仓库,部署自己的jar到这个类型的仓库,包括releases(公司内部发布的版本)和snapshot(内部测试版本)两部分;
            2.proxy,代理仓库,用于代理远程的公共仓库,如maven中央仓库,用户连接私服,私服主动去中央仓库去下载jar包或者插件!
            3.group,仓库组,用来合并对个hosted/proxy仓库,通常我们配置自己的maven连接仓库组.
            4.virtual:兼容Maven1版本低额jar或者插件!
        central:代理仓库.代理中央仓库
            
    nexus仓库默认在sonatype-work目录中:

    
SVN和Maven的结合使用:
    只有svn:
        缺点:
            1.开发人员本地需要所有的代码,编译慢,
            2.部分出错影响整体开发,效率低下
        优点:
            1.编译不会出错;悲观提交!
            2.构建不会出错;
    引入maven:
        优点:
            1.每个人只负责自己的模块,开发速度快
            2.解耦
            3.职责划分清晰
        缺点:
            1.高层模块的构建依赖于底层模块
            2.提交到svn之后可能造成全量编译失败;
结合使用需要注意几点:
            1.提交了代码,需要同时将模块deploy进远程仓库;
            2.在pom里将构建更新的策略设置为always
            3.加入CI系统,提交代码之后由CI系统(hudson),来完成deploy动作;
            或者使用SCM插件,绑定到deploy阶段,在deploy成功之后插件会完成提交动作;
            4.如果提交之后,在svn上全量编译失败,CI系统会第一时间通知相关人员;
    
看书知识点:
        1.maven_opts的值修改为-Xms128m 和-Xmx512m是因为java默认的最大可用内存往往不能满足Maven运行的需要,项目较大的时候会报出java.lang.OutOfMemeoryError;
        2.尽量使用全局的settings.xml配置而不要修改cofg下的setting文件,采用前者在升级的时候不会触动settings.xml文件;
        3.不要使用IDE内置的maven版本,版本冲突或者是新版本会出现一些问题;
        4.POM(Project Object Model,项目对象模型),定义了项目基本信息,描述了项目构建,声明了项目依赖!
            1)groupId和artifactId和version,在maven世界中任何的包都基于这些坐标划分;
            name属性只是声明一个更加友好的项目名!
            2)pom文件中的dependency中的classifier属性:当引入的构件有附属构件并且版本产生冲突的就需要定义classfier;
                              <groupId>net.sf.json-lib</groupId>   
                                <artifactId>json-lib</artifactId>   
                                <version>2.2.2</version>  
                                <classifier>jdk15</classifier>    
                            </dependency>  
            有jdk15和jdk13,一时为了区分,二是为了完整路径;
        帮助定义构件输出的一些附属构件.附属构件与主构件对应
跨平台的数据交互只能是流或者是json串;    
Spring3和4的区别,4中将注解开发中的部分功能抽取到了AOP中;
poi excl报表的导入和导出
cxf 规范http协议;   
shiro java安全
org.quartz-scheduler  定时任务;
分清工程之间的依赖和jar包之间的依赖;
工程之间的依赖只是为了引用的作用
如果Spring配置文件放在WEB-INF下,不需要配置xml的context中的值;
在eclipse中只能添加有xml配置的工程;
将boss------install到本地仓库,作为引用;   
在web.xml文件中加载配置文件的方法:
                    加*  保证格式正确 就会自动扫描
  -03-12  Orcle
    仅主机:局域网
    net模式:关联上网
    桥接:网段是IP前三位;
    登录:
    system/orcl@192.168.6:1521(默认端口号)
    修改监听器和服务之后,如果连不上,去服务重启二者,顺序不能乱;    
    orcle的中文乱码解决        
    concat连接字符串在musql中可以连接多个在orcle中只能连接两个,在orcle中连接多个字符串使用||,
    orcle张除了别名,都用单引号
    nulls last
    
    单行函数:作用于一行,返回一个值;
    多行函数:作用于多行,返回一个值;
    dual虚表:占位,补全语法,没有任何意义;
    在musql中可以没有from,但是orcle中不能没有,和虚表结合使用!
    
    fm====不满10去0;多用于时间月日和时分秒;
    
    将数值函数trunc(数值)引用到按天统计;
    
    nullif 参数一样输出null,否则第一个
    coalesce 输出第一个不为null的参数;
    
    case when then else end  mysql和 orcle通用,orcle中有特殊形式 decode(省略关键字,用逗号隔开)

    distinct 去重!
    group by出现的原始列可以不再select后出现,但是在select 后出现的原始列,必须在group后出现;
    
    where过滤分组之前的,having过滤分组之后的

    集合运算的特征:集合运算两边查询的字段数量、字段类型、顺序必须一致;
        并集: union 或者 union all
        交集: intersect
        差集: minus
orcle的安装:
    创建新的网卡 IP是192.168.149.6
    
多表查询:
    查询语句:查询的列名称写出来;
    自连接:同表起别名,写主外键条件;
  -03-17    
表空间:ORACLE数据库的逻辑单元;
    数据库和表空间:
        一个表空间可以与多个数据文件(物理结构)关联,一个数据库下可以建立多个表空间,一个表空间可以建立多个用户,一个用户下可以建立多个表;
    格式:
        创建表空间:
        create tablespace 表空间名
         detafile '数据文件的路径'
         size 初始大小
         autoextend on
         next 一次自动增长的大小;
        
        全部删除: including contents and datafiles;
        
        创建用户:
         create user itcastuser
         identified by 用户的密码
         default tablespace 表空间的名称
    表和其他的数据库对象都存储在用户下,其实用户就相当于一个更大的表;
    用户的权限:connect resource DBA
    grant dba to itcastuser

orcle中的sql语句大多数和mysql中的是相同的:
        主键,外键,非空,检验(chaeck 字段 in(值得数组)),唯一约束;
        主外键关联强制删除:drop table 表名 cascade constraint;
        级联删除: on delete cascade;
        自定义主键:constraint  名称 primary key (pid )
其他的数据库对象
    视图:封装了一条复杂查询的语句,一个虚表;类似于子查询;
        创建:create view 视图名称 as 查询语句;
             create or replace view 视图名称 as 查询语句 with read only;
        类似的格式,可以复制表;
        修改视图会同步到原表
    序列:数据表中自动增长的列,需要创建之后用户手动实现!
    orcle会将序列值装入内存中以提高效率;
    nextval 下一个
    currval 取得序列的当前内容
        序列可能产生裂缝的原因:回滚,系统异常,多个共用一个序列;



orcle的索引:



    
    索引的概念:
    用于加速数据存取的数据对象
        唯一索引如果条件上有单行函数或者分组操作,模糊查询,都不触发;因为只认识本字段!!!!!!!!!
            单列:基于单个列所建立的索引;
            create index 索引名 on 表名(列名)
            复合:基于两个或者多个列的索引,同一张表上可以有多个索引,但是列的组合必须不相同;
            如果要触发符合索引,必须带上优先检索列;
            第一列为有限检索列;or不触发;只要带优先检索列就会触发;
            create index 索引名 on 表名(列明,列明)
            创建之后,按正常的查就好了
            自己创建的索引可以直接删除,主键约束或者唯一约束产生的索引不能直接删除;
    索引分类:
        B树索引:用于OLTP,适合创建在选择性高的列上;
        位图索引:用于OLAP,适合创建在选择性低的列上;
        复合索引:前缀性,可选性;
        函数索引:将函数作为查询的索引条件;
        反向索引:解决按顺序递增或者递减的时候导致索引块分裂过快的问题;
    索引的场景:
        适用:主键,常用的表连接字段,常用的排序字段,常用的搜索范围字段
        不适用:选择性太低的字段,经常update的字段,控制很多的字段,很少适用的字段





    同义词:缩短了对象的名称
        create public synonym 名称 for 需要创建的名称;
        
    按用户导入和导出:dmp格式的文件
    exp system/orvl owner=   file =
    imp system/orcl  file=   fromuser=  touser=
    按表导出和导入:
    exp 导出源的用户名/密码 file=   tables=
    imp 导入的用户名/密码 file=   tables=
    
    orcle中的类型的容量:blob和clob是4GB,long是2GB;
    
    
    
    PL/SQL语句(procedure language /SQL):ORCLE对sql语句的过程化拓展,在sql命令中增加了过程处理语句;
        declare   ----变量
          说明部分    --:=就是等于号
          引用类型     %type;
         begin    ----逻辑
            语句序列
         exception
          里外处理语句
        End
    常量和变量的定义:不能被输出;
        引用类型的定义:empename%type:变量赋值
        记录类型的定义:emp%rowtype 即对象
    控制台输入数字  pnum
          输出:dbms_output.put_line(内容)
    循环语句:
        1.while step<=10 loop  .....end loop
        2.loop exit 条件......end loop
        3.for i in (条件) loop ...end loop
    
    
  -03-18
    游标:可以存储查询返回的多条数据;
        语法:cursor 游标名 [参数名,类型] is select 语句;
        用法:打开游标
             取一行游标的值
             关闭游标释放资源
             游标的结束方式:exit when 游标名%notfound;
        定义类型: sys_refcursor 并使用open 变量 for 赋值,得到一个打开-有值的游标;
        定义并赋值:cursor 游标名;
    列外:
        系统定义的异常:
            no_data_found 数据未找到
            too_many_rows
            zero_divide 被0除
            value error 算数或转换错误
            time_on_resource 等待资源超时;
        用户自定义:
            exception  when no_data then
                dbms_output_out
                    put_line .put_line('');
        存储函数:返回值类型不能加长度;调用的时候,如果有返回值,必须接收!
        存储过程:因为没有返回值,所以在参数列表中指定out参数,格式  参数名称 out 参数类型!
        out参数的类型可以使任意类型,比如游标类型
        
        所有涉及到赋值操作(:=,into),参数类型必须是out类型;
        inout类型的参数,同时具备二者功能
        
        java调用:orcle10g用的jar包版本是14;
                 orcle11g用的jar包版本是6    
  -03-17
存储过程:就是一个方法,通过传参执行sql语句,经过编译后存储在数据库中;
create or replace  procedure 过程名 [(参数名 in/out 数据类型)]
as或者is
begin
   子程序体
end;
存储函数和存储过程的区别:函数有返回值,过程没有返回值!
输出语句:dbms_output.put_line(内容  ||是连接字符串的)
java连接orcle的jar包   ojdbc14.jar
driver=“orcle.jdbc.OracleDriver”
url=“jdbc:orcle:thin:@IP地址:1521:数据库名”
如果使用java调用函数或者过程,返回的结果是游标的时候需要涉及到一个新的类 是callableStatement的子类,叫orclecallableStatement,这个类型的对象才能得到游标,然后遍历
连接调用prepareCall方法 参数格式 {call 函数或者过程 (参数一样使用?代替)}
注册out类型的函数registerOutParameter(2,OrcleTypes.NUMBER);
使用游标测试多一个遍历
orcle和mysql中的一些区别:
Orcle与MySQL的SQL语法区别:
1.在Oracle中用
select * from all_users显示所有的用户,
而在MySQL中显示所有数据库的命令是
show databases
对于我的理解,Oracle项目来说一个项目就应该有一个用户和其对应的
表空间,而MySQL项目中也应该有个用户和一个库,在Oracle(db2也一样
)中表空间是文件系统中的物理容器的逻辑表示,视图,触发器和存储过
程也可以保存在表空间中。而MySQL并并没有使用表空间来进行管理你。
2.查询当前所有的表
Oracle
select * from tab
MySQL
show tables
3.改变连接用户(库)
Oracle
conn 用户名/密码@主机字符串
MySQL
use 库名
4.显示当前连接用户(库)
Oracle
show user
MySQL
connect
5.执行外部脚本命令
Oracle
@a.sql
MySQL
source a.sql
Oracle数据库与MySQL数据库的区别是本文我们主要介绍的内容,希望能够对您有所帮助。
1.组函数用法规则
mysql中组函数在select语句中可以随意使用,但在oracle中如果查询语句中有组函数,那其他列名必须是组函数处理过的,或者是group by子句中的列否则报错
eg:
select name,count(money) from user;这个放在mysql中没有问题在oracle中就有问题了。
2.自动增长的数据类型处理
MYSQL有自动增长的数据类型,插入记录时不用操作此字段,会自动获得数据值。ORACLE没有自动增长的数据类型,需要建立一个自动增长的序列号,插入记录时要把序列号的下一个值赋于此字段。
CREATE SEQUENCE序列号的名称(最好是表名+序列号标记)INCREMENT BY 1 START WITH 1 MAXVALUE 99999 CYCLE NOCACHE;
其中最大的值按字段的长度来定,如果定义的自动增长的序列号NUMBER(6),最大值为999999
INSERT语句插入这个字段值为:序列号的名称.NEXTVAL
3.单引号的处理
MYSQL里可以用双引号包起字符串,ORACLE里只可以用单引号包起字符串。在插入和修改字符串前必须做单引号的替换:把所有出现的一个单引号替换成两个单引号。
4.翻页的SQL语句的处理
MYSQL处理翻页的SQL语句比较简单,用LIMIT开始位置,记录个数;PHP里还可以用SEEK定位到结果集的位置。ORACLE处理翻页的SQL语句就比较繁琐了。每个结果集只有一个ROWNUM字段标明它的位置,并且只能用ROWNUM<   100,不能用ROWNUM>80。
以下是经过分析后较好的两种ORACLE翻页SQL语句(ID是唯一关键字的字段名):
语句一:
SELECT ID, [FIELD_NAME,...] FROM TABLE_NAME WHERE ID IN ( SELECT ID FROM (SELECT ROWNUM AS NUMROW, ID FROM TABLE_NAME WHERE 条件1 ORDER BY 条件2) WHERE NUMROW > 80 AND NUMROW < 100 ) ORDER BY 条件3;
语句二:
SELECT * FROM (( SELECT ROWNUM AS NUMROW, c.* from (select [FIELD_NAME,...] FROM TABLE_NAME WHERE 条件1 ORDER BY 条件2) c) WHERE NUMROW > 80 AND NUMROW < 100 ) ORDER BY 条件3;
5.长字符串的处理
长字符串的处理ORACLE也有它特殊的地方。INSERT和UPDATE时最大可操作的字符串长度小于等于4000个单字节,如果要插入更长的字符串,请考虑字段用CLOB类型,方法借用ORACLE里自带的DBMS_LOB程序包。插入修改记录前一定要做进行非空和长度判断,不能为空的字段值和超出长度字段值都应该提出警告,返回上次操作。
6.日期字段的处理
MYSQL日期字段分DATE和TIME两种,ORACLE日期字段只有DATE,包含年月日时分秒信息,用当前数据库的系统时间为SYSDATE,精确到秒,或者用字符串转换成日期型函数TO_DATE(‘2001-08-01’,’YYYY-MM-DD’)年-月-日24小时:分钟:秒的格式YYYY-MM-DD HH24:MI:SS TO_DATE()还有很多种日期格式,可以参看ORACLE DOC.日期型字段转换成字符串函数TO_CHAR(‘2001-08-01’,’YYYY-MM-DD HH24:MI:SS’)
日期字段的数学运算公式有很大的不同。MYSQL找到离当前时间7天用DATE_FIELD_NAME > SUBDATE(NOW(),INTERVAL 7 DAY)ORACLE找到离当前时间7天用 DATE_FIELD_NAME >SYSDATE - 7;
MYSQL中插入当前时间的几个函数是:NOW()函数以`'YYYY-MM-DD HH:MM:SS'返回当前的日期时间,可以直接存到DATETIME字段中。CURDATE()以’YYYY-MM-DD’的格式返回今天的日期,可以直接存到DATE字段中。CURTIME()以’HH:MM:SS’的格式返回当前的时间,可以直接存到TIME字段中。例:insert into tablename (fieldname) values (now())
而oracle中当前时间是sysdate
7.空字符的处理
MYSQL的非空字段也有空的内容,ORACLE里定义了非空字段就不容许有空的内容。按MYSQL的NOT NULL来定义ORACLE表结构,导数据的时候会产生错误。因此导数据时要对空字符进行判断,如果为NULL或空字符,需要把它改成一个空格的字符串。
8.字符串的模糊比较
MYSQL里用字段名like%‘字符串%’,ORACLE里也可以用字段名like%‘字符串%’但这种方法不能使用索引,速度不快,用字符串比较函数instr(字段名,‘字符串’)>0会得到更精确的查找结果。
注意:select * from tablename where 字段名 like ‘%陈%’?=select * from tablename where instr(字段名,’陈’)>0
9.程序和函数里,操作数据库的工作完成后请注意结果集和指针的释放。

触发器:特殊类型的存储过程,在指定的表中的数据发生变化的时候生效。唤醒调用触发器以响应相应的数据库操作语言。触发器可以查询其他表,并可以包含复杂的Transact-sql语句;将触发器和触发它的语句作为可以在触发器内回滚的单个事务对待,检测到严重错误,自动回滚;
        
    触发器与约束的比较:
         触发器:
1.可以包含使用事务sql代码的复杂处理逻辑。触发器支持约束的所有功能,但并不是最优的方法;
2.自定义错误信息,并可以实现复杂的错误处理;
3.可以引用其他表中的列;
4.评估数据修改前后的表状态,并根据其差异采取对策;
5.如果触发器表上存在约束,则在instead of 触发器执行后和after触发器执行前,检查约束,破坏约束则回滚到instead of 触发器操作;
        约束:
1.只能根据逻辑表达式活着同意表中的另一列来验证列值;
2.只能通过系统的标准错误信息来传递错误信息;                
          
    类型:
        语句级触发器:
        在制定的操作语句之前或之后执行一次,不管这条语句影响了多少行;        
        行级触发器(for each row):
        触发语句作用的每一条记录都被处罚。在航迹触发器中使用old和new伪记录变量,识别值得状态;

  -03-17
        =和in的用法:
            返回一个结果的时候用=,但是所有的都推荐用in,使用in的时候必须去掉子查询中的null值;
        sql语句中的循环;
        orcle的分页:
        rownum
        物理地址 rowid 固定不变 可以在plsql中修改数据;    
        外链接的加号:
        where e.id(+)=p.id;飞
        要显示哪张表,就将加号放在对面;
    
html5新特性:1)语义化标签
            2)kvs画布
            3)新的属性和属性值

java实现的CMD远程控制程序:
    //WinAPI:windowsAPI的简称,是微软对于windows操作系统中可用的内核应用程序编程接口的叫法,设计为由C/C++程序调用,是应用程序与windows系统最直接的交互方式;
    //.NET是Microsoft XML Web services 平台;XML Web services允许应用程序通过Internet进行通讯和共享数据,而不管所采用的是那种操作系统、设备或编程语言,Microsoft.NET平台提供XML Web servicesbingjiang这些服务继承再一起之所需.
        .NET Framwork是有微软开发,一个致力于敏捷软件开发、快速应用开发、平台无关性和网络透明化的软件开发平台;
    Unix和Linux的区别:
        相同点:二者都是操作系统,linux是unix的衍生版;
        不同点:linux是开源的自由软件,unix是知识产权受保护的商业软件
               unix系统大多是与硬件配套的,linux可以运行在多种硬件平台上
        Unix一直被用作高端应用或服务器系统,有一套完善的网络管理机制和规则,一直被linux沿用
        
//☆为一级标题  □为二级标题 △为三级标题
项目一:
BOS(Bussiness Operating System) 业务操作系统;
一、项目概述:
    ☆项目背景介绍
        1.全网页操作模式;
        2.周期13个月,编码4个月,大概20人;
    ☆常见软件类型
        1.OA:办公自动化系统
        2.CRM:客户关系管理系统
        3.ERP:企业整体的解决方案(平台)
    ☆软件开发流程(瀑布模型)
        □瀑布模型:
            1.定义阶段:    
                可行性研究:
                需求分析:
            2.开发阶段:
                设计(概要和详细两部分):文档,原型,数据库;
                编码:单元测试
                测试:黑白盒测试,压力测试,负载测试;
            3.维护阶段
                上线运维:
    ☆技术选型
        □开发环境: windows       Eclipse 4.5   mysql5.5  Tomcat7.0 火狐
        □产品环境: linux rhel-server-6.3      Mysql 5.1.6 Tomcat 6
        □技术选型: Struts2 2.3.24  hibernate 5.0.7  Spring 4.2.4 Junit 4 Jquery 1.8.3;
  -04-02
    全新的安全框架--Shiro
    shiro安全认证框架:apache提供的一个安全认证框架,相比Spring security相比,使用了比较简单易懂的认证和授权方式.
    native-session机制:用户把认证后的授权信息保存在其自身提供的session中;
    应用程序的四大基石:
        1:Authentication:证明用户身份的行为,策略组会确定行为结果;
        2:Authorization:访问控制的过程;
        3:Session Management:管理用户特定的会话,即使在飞Web或EJB应用程序
        4:Cryptography:把JDK中复杂的摩玛加密方式进行封装;
    常用功能:Caching:缓存技术;
             Concurrency:多线程
             Testing:测试
             Run As:身份转换功能,管理脚本;
             Remember me:记住用户身份功能;
    Subject是与程序进行交互的对象,理解为用户,必须绑定到SecurityManager上,
    我们与一个subject交互,运行时shiro会自动转化成与SecurityManager交互的特定的subject的交互;(理解为连接)
    SecurityManager:shiro的核心,协调各个组件;
    Realms:在shiro获取安全数据判断subject的权限与数据库交互;配置的时候至少要有一个;
    Authenticator:登录控制;
    SessionManager:如果写过Servlet就应该知道Session的概念,Session呢需要有人去管理它的生命周期,这个组件就是SessionManager;而Shiro并不仅仅可以用在Web环境,也可以用在如普通的JavaSE环境、EJB等环境;所有呢,Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据;这样的话,比如我们在Web环境用,刚开始是一台Web服务器;接着又上了台EJB服务器;这时想把两台服务器的会话数据放到一个地方,这个时候就可以实现自己的分布式会话(如把数据放到Memcached服务器);
    SessionDAO:DAO大家都用过,数据访问对象,用于会话的CRUD,比如我们想把Session保存到数据库,那么可以实现自己的SessionDAO,通过如JDBC写到数据库;比如想把Session放到Memcached中,可以实现自己的Memcached SessionDAO;另外SessionDAO中可以使用Cache进行缓存,以提高性能;
    CacheManager:缓存控制器,来管理如用户、角色、权限等的缓存的;因为这些数据基本上很少去改变,放到缓存中后可以提高访问的性能
    Cryptography:密码模块,Shiro提高了一些常见的加密组件用于如密码加密/解密的。
shiro的配置:
    1.在xml中配置过滤器DelegatingFilterProxy,过滤器的代理对象
    由Spring创建
    2.在applicationContext中配置ShiroFilterFactoryBean,参数有返回值路径,安全管理器(配置bean)和校验规则;
    3.配置需要的relam,注入到安全管理器中
shiro的权限控制四种方法:
    1.Url控制,在Spring的ShiroFilterFactoryBean配置中的参数
    2.方法注解方式(基于代理实现的):使用cglib动态代理不适用java的JDK,因为注解加在方法上,所以不能使用被代理类的方法;
        配置自动代理类,然后在要控制的方法上加注解        
    <bean id="defaultAdvisorAutoProxyCreator" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
        <!--
            true 使用cglib
            false使用jdk动态代理
          -->
    <property name="proxyTargetClass" value="true"/>
    </bean>
    <bean id="authorizationAttributeSourceAdvisor" class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor"></bean>

    动态代理:
        1.cglib代理:
        2.java的JDK动态代理基于同一接口代理:
    3.权限标签 类似于struts标签的引用和使用
    4.编程实现  在要实现的方法执行前获得已经认证的subject,然后调用check方法;
struts的全局异常映射:
    <global-exception-mappings>
        <exception-mapping result="路径" exception=""
  -03-24
知识点和要注意的地方:
            1.渲染datagrid:是根据field来接受数据
            2.toolbar 的handler属性可以使标志具有方法; handler:function(){};
            3.pageBean中封装条件,total和rows关键词不能改,easyui不识别;
            4.datagrid中获取选中行的方法返回值是这行的对象
            5.js的数组中有一个分割的方法,只能填充 join();
            6.表单校验:需要校验的项目上加属性easyui-validate     加条件的时候使用data-options="validType:"
                默认的只有邮箱,地址和长度remote['http://.../action.do','paramName']: 发送ajax请求做验证值,返回“true”当成功。
            自定义校验规则:
            $.extend($.fn.validatebox.defaults.rules, {

                                    minLength: {

                                    validator: function(value, param){

                                    return value.length >= param[0];

                                },

                                    message: 'Please enter at least {0} characters.'

                                    }

                                    });
                                    });
                                    });
            7.回显使用的datagrid的双击方(rowindex,rowdata) : 第几行和每行的对象     
  -03-25
知识点和要注意的地方:
            1.OCUpload:利用事件局部上传,利用target刷新到隐藏界面;类似于ajax的post,参数也类似
            2.poi使用总结:四个常用对象按顺序读取:HSSFWorkbook 文档对象
                                                 HSSFSheet excel的sheet 页,根据索引和名称
                                                 HSSFRow excel的行
                                                 HSSFCell excel的单元格
            3.分页查询的代码优化:将重复代码放到公用类的/构造,属性和方法中;                                    
            4.使用json转换对象中缺少的属性可以不用定义直接赋予get方法;  json的转换只要有get方法就好;
            5.combombox默认支持基本数据查询:属性是mode   local本地,romote远程(将输入的值当做参数传递到后台);
            6.如何循环遍历给对象的属性赋值; 注解中有没有表明索引的
            7.单元格的索引是从0开始的
  -03-26
知识点和要注意的地方:
            1.将表单转化为json数据传递到后台;使用load方法,百度转换代码  fn类似于java中的object
            2.在一张表中查另一张表的非主键属性的时候需要给另一张表起别名,使用离线查询的createAias;(别名)
            3.多表查询得到多对象,将结果集设定为条件查询创建的时候绑定的实体,在设置sql之后,否则会被重置;
            4.数据导出:
            5.关闭延迟加载,谁被关联关谁    
利用EasyUI的增删改查:
            增加:主键的生成策略;方法使用saveOrUpdate();
            删除:传递ID,一般是修改flag,并不是真正意义上的删除;
            修改:update,也要注意主键,是根据id查询;回显都是使用EasyUI封装好的插件和方法;
            查询:命名查询(语句定义在实体的映射文件中)和离线查询和分页查询;
            
代码生成器读后感:
            1.用到枚举,不太会; 枚举中的su是什么,感觉这个工具类完全依赖于枚举,每次调用方法都会加上su;
            2.将末班读到StringBuilder中,应该是好切割,好替换的原因,因为在文件中替换会再次进行开流关流,不好控制,但是如果模板过长的话,StringBuilder(最大长度可以保存30M文件)会不会不够长();
            
            
webService(远程调用):web服务,一种跨编程语言和夸操作系统平台的远程调用技术及跨平台远程调用技术;
                    1.采用的使SOAP协议(基于http协议,属于3c标准)传输xml数据;
                    2.采用wsdl所谓描述语言,即说明书,也属于w3c标准;
                    3.xml的完全解耦性;
                    4.XSD webservice的数据传输类型,使用xml进行描述(XML,Schema Datatypes),经过webservice传输必须转换成这个格式;
                    5.非SOAP协议的webService以轻量级为首要目标,http的rest方式也是webservice的一种,或者直接使用http自定义数据协议,比如xml和json;
            三要素:
                    1.soap(Simple Object Acess Protocal)简单对象访问协议
                    2.wsdl说明书
                    3.UDDI一种目录服务,可以进行注册或通过它查找注册的webService服务;全球共享(一般不用)
    服务端开发:
            1.编写接口:成为porttype;
            2.编写实现类 必须有至少一个非静态方法来供注解@webService实现;
            3.调用Endpoint的publish方法发布服务,参数是地址和实现类的对象
            4.查看地址加?wsdl
    客户端编写:
            1.使用wsimport进行代码生成
                JDK自带的webservice客户端工具
                格式为:wsimport -s(生成.java文件) -d(class文件默认就有) .(默认目录)/-p(新的包名) wsdl地址;
            2.创建服务视图对象
            3.获得服务对象,调用方法,使用返回值;
            @webService 注解的作用:发布类中所有的public方法;
            java开发有JDK版本限制:1.7;
            
CXF框架整合Spring实现远程调用:
            服务端:
                1.需要增加标签<jaxws:server address属性(web工程使用tomcat不用写全地址,只写服务名称就好)
                                serviceClass="接口的全路径名">
                                <jaxws:serviceBean><ref bean="注入的名称"></jaxws:serviceBean>
                                </jaxws:server>
cxf版本问题:低版本不能解析address属性;
将自己要使用的包导入到maven仓库,执行下面的命令!
mvn install:install-file -DgroupId=com.taobao -DartifactId=alidayu -Dversion=1.0 -Dpackaging=jar -Dfile=jar包完整路径
            
  -03-29
知识点和需要注意的地方:
        1.将webService导入到maven仓库中,和工具类一样的;
        2.datagrid的columns中开启复选框;
        3.在datagrid中开启单选;
        4.全局变量的定义;
        5.用到了事件:doClickRow
        7.formatter属性的三个参数 第一个只能获取基本类型,获取不到用第二个
Session的种类:
        httpsession(http中的session):
        session(websocket中的):
        session(apache.catalina):
单点登录(Single Sign On):简称为SSO,多个应用系统中,用户只需要登陆一次就可以访问所有相互信任的应用系统.


tomcat+Ngixn+Session高性能集群的搭建:


Timestamp  时间戳 精度高 精确到毫秒;
  -03-30
    datagrid的快速录入:
    JS时间格式转换:new Date(对象.字段.time).toLocalString();
    
    
    
  -04-02
    SimpleAuthenticationInfo(principal(任何地方都可以获取到,是session吗),credentials(密码),realmName);
  -04-03
    数据库查询权限和角色:
        pid(默认值是规定的)的get方法生成,使用的是getpId();
    ztree获取ztre对象然后获取选中节点的值;
    根据用户查询权限的时候:
        1.需要判断是否为admin
        2.查出来之后使用内连接 list中封装了多个字段,并不是一个对象,需要控制!
    查询权限的时候,用户角色过多之后,会产生重复数据,需要去重
    权限缓存-shiro的缓存:
    ehcache:1.导包
            2.由Spring创建
            3.由shiro的安全管理器管理,所以要注入到安全管理器中
    Ehcache是一个纯java的进程内缓存框架,是一种广泛使用的开源的分布式缓存,是hibernate中默认的CacheProvider.
            MyBatis提供二级缓存接口Cache接口,通过实现Cache接口可以实现mybatis缓存数据与其他缓存数据的整合;mybatis的特长
        是sql操作,缓存数据的管理不是mybatis的特长,为了提高缓存的性能将mybatis和第三方的缓存数据库整合,比如ehcache和redis;    

  -04 新的知识点和工具
    1.EXT_JS前段新框架
    2.Itext  利用jsp或者javaBean生成PDF报表的java组件
        报表:多样的格式+动态数据;
    3.jfreechart 开发多样的表格 比如柱状图 饼状图等;
    4.solr 独立的企业级搜索应用服务器,对外提供类似于webService的API接口,向搜索引擎提供一定格式的xml文件,生成索引;也可以通过
           Http的get操作提出查找请求,得到xml格式的返回结果;
    5.Spring的aop开启自动代理和shiro注一起使用的时候会因为二次代理造成Spirng的aop代理失效!
        解决办法:将shiro创建自动代理的bean注释掉或者给DefaultAdvisorAutoProxyCreator加入参数proxyTargetClass为true
        
  -04-05
    Quartz:定时任务
        1.导包,和spring整合使用的是context-support包和Quartz的两个包
        2.配置   job  jobdetail  trigger
    JavaMail:java实现收发邮件
    highcharts
  -04-06
linux的权限:
    r:读
    w:写
    x:执行
    -:没有权限
    权限总体表达式:
        第一组:当前文件所属用户的权限
        第二组:当前文件所属组的权限
        第三组:其他用户或组权限
    搜索关键字  /加内容
    切换用户  su
    解压 tar -zxvf    
监控 tomcat运行
    jsp:jdk提供的监视tomcat的命令
    日志中的catalina.out文件==控制台内容
    cat: 直接将文件打出来
    tail -f 文件名:监控文件新内容
    
no-session的解决办法:    
采取的是关闭全局的延迟加载。
在hibernate中我们可以根据我们的业务需要动态的关闭延迟加载的属性。
采取的操作就是Hibernate.initialize(user);
但在使用时需要注意的一点是:
其中的proxy是持久对象的关联对象属性,比如A实体,你要把A的关联实体B也检出
,则要写Hibernate.initialize(a.b)。    
        
struts配置文件中action实例创建的默认class是actionsupport方法execute;

min文件是为了减少占用空间的压缩版本,去掉没有用的空格之类的
注解中默认的name属性是类名首字母小写;
@AutoWired:自动装配:
@Qualifier:强制使用名称注入     只是简单的注入
@Resource 代替二者  
注解加在方法上,代表给参数赋值和方法的执行;
验证一下required和length[0,100] 冲突吗?
命名查询:利用配置文件的先行性,将常量以健值对的形式配置在hbm.xml文件中,然后使用session获取,给参数赋值,执行sql;
正则校验的方法:test();匹配正则的格式:/^内容$/
编程规则中exit()方法只能在main方法中调用
set serveroutput on;  开启服务器输出功能;
泛型可以使用?代替object;只读不写的类型!!
使用离线查询的时候才,使用的projection 是为了设置hibernate的默认查询语句;
设置为null回复默认;
eof异常表示输入过程中意外到达文件末尾或者流的末尾,导致从session中获取数据失败,session的持久化机制引起的,本意是在tomcat重启时保持之前的session,但是异常关闭后,一些活动的session被持久化(表现为一些临时文件)tomcat试图恢复session时读取失败,抛出异常;
解决办法:清除session的持久化文件 ser格式的;
前后台数据数量不一样,可以利用持久态自动更新数据库来保存编辑之后的数据;
json-lib工具中:JSONObject 转换对象  JSONArry转换所有的集合;支持排除不需要数据,jsonConfig的类中的setExclude(数组);
fastJson中排除解析对象 @JSONField(serialize=false)
    private Set<Linkman> linkmans = new HashSet<Linkman>();
    String json = JSON.toJSONString(list, SerializerFeature.DisableCircularReferenceDetect);



DB2:分布式数据库解决方案;大型关系型数据库,支持多用户或应用程序在同一条sql中查询不同的database甚至不同的dbms中的数据;版本:Unix,windows,as/400,os/390
    技巧:1.一般不要使用teb会编译不通过;
         2.bd2的临时表只在一个session内有效,如果程序有多线程,不要使用临时表;
         3.临时表只能建在user tempory tables space 上,如果database只有system tempory table space是不能建临时表的。

SpringMVC:基于java实现web mvc设计模式的请求驱动类型的轻量级web框架;使用了mvc架构模式的思想,讲web层进行职责解耦.使用请求相应模式;
    前段控制器:DispatcherServlet;
    应用控制器:
              1.处理映射器:注解式处理器映射器:对有注解的方法进行映射,根据定义的rul匹配标记的方法,匹配成功之后返回HandlerMethod(封装url对应的方法的method)对象给前段控制器;
                        使用RequestMappingHandlerMapping  映射器            
              2.处理器适配器:对标记的方法进行适配 类似于装饰者;
                        使用RequestMappingHandlerAdapter  适配器
                MVC使用<mvc:annotation-driven> 自动加载映射器和适配器
              3.试图解析器(view Resolver):页面管理
              使用框架默认的InternalResourceViewResolver
              <bean
                class="org.springframework.web.servlet.view.InternalResourceViewResolver">
                <!-- 配置逻辑视图的前缀 -->
                <property name="prefix" value="/WEB-INF/jsp/" />
                <!-- 配置逻辑视图的后缀 -->
                <property name="suffix" value=".jsp" />
             </bean>
             逻辑视图名称需要modelandview指定,
    页面控制器/动作处理器为Controller接口的实现(仅包含ModelAndView handlerRequest(request,response)方法);
    支持本地化解析,主题解析及文件上传,灵活的数据验证-格式化和数据绑定机制;提供了强大的约定大于配置的契约式编程支持;
    ===================================================================================
    1.组件扫描器:就是注解扫描器 扫描有注解的类
SpirngMVC单独运行搭建步骤:
    1.导包
    2.需要一个类似于Spring的配置文件
    3.配置web.xml中的Servlet接受请求,设置过滤所有的action请求
    
MyBatis学习笔记:
    MyBatis:想要回去插入数据的自增主键,使用select last insert id();在配置文件中,mysql使用after,orcle使用before  orcle的序列是先于插入语句形成的;
        动态代理Mapper
            开发规则:使用的是cglib的方式
                1.接口与mapper文件在同一包下;
                2.两种文件的名称必须一致;
                3.mapper文件的命名空间必须是接口的全路径名;
            调用规则:
                1.接口的方法名与mapper文件中的id保持一致
                2.接口的入参与mapper文件中的parameterType的类型保持一致
                3.返回值类型与resultType的类型保持一致
        #和$的区别:
        ${}时字符串的拼接  内部只能写value 而#{}是占位符 普通编写可以是任意值,mapper接口编写只能与字段相同;
        直接传入数组的时候,type是数组的new形式 Integer[]; foreach中是小写;
传统的增删改查:
        除了查不需要提交事务,其他的都需要;在更新的时候因为不能保证每个字段都要修改,使用set标签代替set关键字,同时可以去掉引号;
MyBatis的DAO开发方法:
        原始的DAO:
            类似于传统的增删改查
        Mapper接口方法:
            遵循规则见上!!!
配置文件:SqlMapConfig.xml
    properties 属性
    settings 全局配置参数
    typeAliases 类型别名
    typeHandlers 类型处理器
    objectFactory 对象工厂
    plugins 插件
    environments 环境集合属性对象
        environment 环境子属性对象
            transactionManager 事务管理器
            dataSource 数据源
    mappers 映射器:
        resource:相对路径的文件
        url:物理地址的文件
        class:只有使用动态代理的时候可以使用接口的类路径
        <package name=""/> 动态代理的时候
        
定义resultMap:第一个使用id,之后所有的都使用result
扫描:配置文件取别名的时候,扫描映射文件的时候
动态sql:使用的标签<set>(处理逗号)<where>(处理and)<if>(要注意空字符串的判断) 基本类型的判断 需要使用(_parameter)不能使用字段名
根据传入的结合类型操作:
    格式:<foreach collection="集合名称(在外部标签中应该是大小写的list都行的)" open="" colse="" items="为遍历内部取值">
        其实就是sql的拼接 标签都为拼接服务;
    传入单个集合或者数组的时候,collection必须写小写的名称
使用sql片段提取公用的sql然后使用include标签通过id引用
延迟加载
<settings>
        <setting name="lazyLoadingEnabled" value="true"/>全局懒加载
        <setting name="aggressiveLazyLoading" value="false"/>每个属性按需加载
</settings>

mybatis整合spring:1.导包
                  2.两个配置文件
                  3.mapper的编写方法
                    1)接口实现类集成SqlSessionDaoSupport:需要将sqlSessionFactory注入到接口的实现类中
                    2)接口开发方法:不俗要写实现类,接口和xml文件满足动态代理的要求,通过MapperFactoryBean创建代理对象(参数:mapperInterface和sqlSessionFactory)--需要配置每个接口
                    3)使用MapperScannerConfigurer进行扫描(可以代替sqlmapConfig中的扫--前提是在一个包),参数是包名和sqlSessionfactory    
    SqlSessionFactory交给Spring创建单利对象;
关掉sqlSession非常重要;
MyBatis的注解开发,将扫描包的resource改为class,那么就注定是使用接口动态代理开发了,例子如下
    public interface UserMapper {
    @Select("select * from blog_db.user where id=#{id}")
    @Results(
        {
            @Result(id = true, column = "id", property = "id"),
            @Result(column = "name", property = "name"),
            @Result(column = "email", property = "email"),
            @Result(column = "password", property = "password")
        })
    User findById(int id);
    @Insert("INSERT INTO blog_db.user (name, email, password) " +
        "VALUES (#{name}, #{email}, #{password} )")
    @Options(useGeneratedKeys=true, keyProperty="id")
    void insertUser1(User user);
    @Insert("INSERT INTO blog_db.user (name, email, password) " +
        "VALUES ( #{user.name}, #{user.email}, CONCAT(#{user.password}, #{passwordSuffix}) )")
    void insertUser2(@Param("user")User user, @Param("passwordSuffix")String passwordSuffix);
}
====================================================================
spring和mybatis整合的思路
    将原本的一个spring的文件拆分成三份,分别给三层,分管service的事务和dao持久层和mybtis整合,springmvc.xml则负责controller的解析;
    感觉就只是web层的一种质的改变,其他层是没有变化的,摒弃了struts对事务的控制,将事务控制无缝整合到spring中,然后高出一个新的框架;
    兼容性很强,将原先的model接口和返回值整合到modelview中
model和modelandview的取值都和原来的是一样的;
====================================================================
  -04-14
SpringMVC:
    1.ModelAndView中的数据其实是在request域中;
    2.在Spring中配置别名 需要一个property属性 扫描包 (配置了spring之后的包扫描是不需要配置别名的)
    3.方法中默认支持的参数类型:
        HttpServletRequest  request
        HttpServletResponse  response
        HttpSession     session
        ModelAndView:试图解析器对象
                                    两种对象都是使用request来传递数据,所以应该是被放在了request域中
                                    使用model可以不使用modelandview
        Model和ModelMap的区别:
        @RequestParam:
        public String editItem(@RequestParam(value="item_id",required=true) String id) {}
        绑定pojo类型和包装pojo类型的时候,表单的name属性是有要求的;    
                
    以上是简单类型和pojo类型!
    4.解决post乱码问题
        在web.xml中配置乱码解决的过滤器:CharacterncodingFilter,
    5.解决get请求的乱码问题
        一种是是用传统的方法编解码
        第二种是修改tomcat配置文件添加编码与工程编码一致;
            <Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
    6.自定义参数绑定
        需要配置类似拦截器一样,必须在注解驱动中引用
            <mvc:annotation-driven conversion-service="conversionService"/>
            <!-- 转换器配置 -->
            <bean id="conversionService"
                class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
                <property name="converters">
                    <set>
                        <bean class="cn.itcast.springmvc.convert.DateConverter"/>
                    </set>
                </property>
            </bean>        
    7.springmvc和struts2的区别:
        1)入口一个是servlet前端控制器(DispatcherServlet)一个是过滤器(strutsPareandexecutefilter)
        2)springmvc是基于方法开发的(一个url对应一个方法),通过请求传递参数到方法参数,可以设计单例或者多例;struts2是基于类开发的,通过类的属性传递参数,只能设计多例;        
        3)springmvc将参数封装成modelandview中的模型数据通过request域传输到页面.jsp视图解析器默认使用jstl;        
    8.绑定高级参数:
        感觉和struts通过类的属性传参差不多,要注意的是表单中name属性必须和参数吻合;
    9.自定义异常:继承exception;
    10.自定义异常处理器:实现HandlerExceptionResolver
    11.在springmvc中的全局异常处理器
        <bean id="customHandleException" class="cn.itcast.ssm.exception.CustomHandleException">
    12.给tomcat设置虚拟目录:conf下的server.xml文件添加
        <Context docBase="服务器本地路径" path="/pic" reloadable="false"/>
        使用http://localhost:8080/pic访问
    13.实现文件上传:需要配置多部件上传解析器
        两个jar包
        <!-- 文件上传,id必须设置为multipartResolver -->
        <bean id="multipartResolver"
            class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
            <!-- 设置文件上传大小 -->
            <property name="maxUploadSize" value="5000000" />
        </bean>        
        在java文件中使用MutipartFile接受上传的文件;
    14.json数据交互:需要使用Jackson包
        1)传统通过get请求传递需要传递的少数参数,使用注解@RequestBody代替,可以读取http请求的内容,通过springmvc提供的HttpMessageConverter接口将读到的内容(json数据)
    转换为java对象并绑定到Contriller方法的参数上.
        =======@RequestBody放在方法上的话,返回值只能是一个单独的实体,放在方法中的可以是list之类的        
        2)ResponseBody注解用于将Controller的方法返回的对象,通过springmvc提供的HttpMessageConverter接口转换为指定格式的数据,通过Response相应给客户端    
            一般使用注解驱动解析以上两个注解,否则需要给处理器适配器加入json转换器;
    15.RESTful:资源定位以及资源操作的风格,基于此风格可以使设计更简洁,有层次,易于实现缓存等机制;
        <mvc:resources location="" mapping="" />
        1)使用注解@RequestMapping("item/{id}")声明请求的url;
        2)使用(@PathVariable("如果和形参名称一致,不需要声明") Integer id)
        3)@PathVariable是获取url上数据的。@RequestParam获取请求参数的(包括post表单提交)
        4)2.如果加上@ResponseBody注解,就不会走视图解析器,不会返回页面,目前返回的json数据。如果不加,就走视图解析器,返回页面
    16:四种注解的区别
        handler method 参数绑定常用的注解,我们根据他们处理的Request的不同内容部分分为四类:(主要讲解常用类型)
            A、处理requet uri 部分(这里指uri template中variable,不含queryString部分)的注解:   @PathVariable;
            B、处理request header部分的注解:   @RequestHeader, @CookieValue;
            C、处理request body部分的注解:@RequestParam,  @RequestBody;
            D、处理attribute类型是注解: @SessionAttributes, @ModelAttribute;
    17:拦截器:用于对处理器进行预处理和后处理
            必须实现HandlerInterceptor
        在springmvc.xml中的配置
        <!-- 配置拦截器 -->
            <mvc:interceptors>
                <mvc:interceptor>
                    <!-- 所有的请求都进入拦截器 -->
                    <mvc:mapping path="/**" />
                    <!-- 配置具体的拦截器 -->
                    <bean class="cn.itcast.ssm.interceptor.HandlerInterceptor1" />
                </mvc:interceptor>
            </mvc:interceptors>
    18.controller方法的返回值
        返回modelandview
        返回model
        返回void
        返回字符串
    19.对url的优化:@RequestMapping()
        可以定义多个url,可以定义统一的前缀窄化请求映射(窄化请求映射,类路径加上方法路径才是全路径)
    20.相对路径的新认识:相对于当前地址栏的路径
    21.printwriter和Stringwriter的使用??
        try {
            
        } catch (Exception e) {
            StringWriter sw=new StringWriter();
            PrintWriter pw=new PrintWriter(sw);
            e.printStackTrace(pw);
            StringBuffer error=sw.getBuffer();
        }
    ====PrinterWriter
    1.PrintWriter可以作为一个过滤流,封装Writer实例,内容输入到PrinterWriter之后相当于直接输入到了Writer实例中,可以直接使用
    2.PrintWriter作为节点流,构造器中接受File对象或者文件名,不能指定编码方式,采用本地默认的编码方式
    3.PrintWriter可进行桥转换,接受一个输入流;
    ====
    StringReader和StringWriter类似于文件的读写
    ====    
    22.resources标签中的location属性指定放行资源的位置,相对于根目录的路径;
                        mapping属性配置映射
    23.druid:阿里巴巴开发的数据库连接池,最快的
    25.父子容器就类似于类的继承 父类不能调用子类的方法
    26.seriable实现序列化(本质是变为key=value形式的字符串)
    27.ssm实现分页查询是使用了com.github.pagehelper;需要引包
    28.插入的时候,需要对象的id和设置对象的id是自增的 使用keyProperty  和useGeneratedkeys (mysql支持)
====================================================================================================================            
  -04-18 Lucene&Solr
数据的类型:
    1.结构化数据:18630804861
    2.非结构化数据:
搜索数据的方式:
    1.顺序扫描法:从头到尾
    2.倒序索引(倒排文件):存储了来自文本中的映射的索引数据结构;提取资源中的关键信息,建立索引,搜索时格局关键字找到资源的位置;
        文档(Document):文件,用来表示文本信息
        文档集合(Document Collection):文档组成的集合(能不能写成toString)
        文档编号(Document ID):搜索引擎内部为每个文档富裕的唯一内部编号
        单词编号(Word ID):与文档编号类似,搜索殷勤内部一卫一的编号来表示某个单词
        倒排索引(Inverted Index):实现单词-文档矩阵的一种具体存储形式.通过倒排索引,可以根据单词快速获取包含这个单词的文档列表;由单词词典和倒排文件组成;
        单词词典(Lexicon):搜索引擎通常的索引单位是单词;搜索时使用的关键词
        倒排列表(PostingList):记载了出现某一个关键词的所有文档的位置信息;每条记录都是一个倒排向(Posting)
        倒排文件(Inverted File):包含单词的文件
    举例:单词序号  单词   在几个文档中出现过     出现的文档编号 出现的次数 单词的位置   编号8—拉斯—2—{(3;1;<4>),(5;1;<4>)}
Lucene:    apache下的一个开放源码的全文检索引擎工具包(完整的查询引擎,索引引擎和部分文档分析引擎)
    1.全文检索流程
        创建索引:原始内容-获得文档-创建文档-分析文档-索引文档
        1.获得文件的流对象
        2.对应每个文档创建一个document对象,每个对象都有域(field),相当于数据库的字段
        每个document可以有相同的域,不同的对象可以有不同的域,但必须有一个唯一的id;
        3.根据空格进行字符串拆分,去除停用词(没有实际意义的),标点符号,大小写 得到语汇单元流
        4.创建索引:便于查询的数据结构; b+tree/b-tree结构;
        基于索引库的检索:
            1.定义关键字
            2.将检索内容转换成query对象
            3.创建索引对象indexSearcher
            4.通过indexSearcher提供的search方法进行检索,检索完成后,返回一个结果集
            5.渲染结果:
                1)根据需求通过结果集获得数据
                2)渲染效果
    2.入门程序
            1.创建一个索引保存目录;
            2.创建一个indexWriter对象,需要两个参数(一个是目录,一个是indexWriterConfig配置)
            3.indexWriterConfig的创建需要两个参数,一个是版本号,另一个是分析器Analyzer对象
            4.获得文档-创建文档-分析文档-索引文档
            5.创建文档对象
            6.添加field
            7.保存文档对象到索引库
            8.关闭indexWriter对象
luke的使用:
分析器的使用
    分词过程:查看分词效果:tokenstream对象 获得指针  复位指针 遍历;
在使用IKAnalyzer分析器的时候不要使用记事本编辑,要时刻保证编码是纯净的utf-8;
  -04-20
    1.索引库的维护
        添加
            Field参数说明:数据类型+Field  是否分析  是否索引 是否存储(枚举)
        删除
            全部删除和条件删除(查询和删除的结合)
        修改
            先删除再添加
        查询
            使用Query的子类查询对象
                TermQuery
                MatchAllDocsQuery
                NumericRangeQuery
            组合条件查询
                BooleanQuery:  使用add添加条件  使用Occur连接条件;
            使用QueryParser
                参数设置默认搜所域
                MulitFieldQueryParser
    2.lucene的查询语法
        1.域名:关键字
        2.域名:[最小值 TO 最大值]
            范围查询在QueryParser中不支持数值类型,支持字符串类型。在solr中支持数值类型。
        3.组合查询
    3.相关度打分:
        1)计算出词的权重
            TermFrequency(tf):词出现的频率
            DocumentFrequency(df):占总体的比例
        2)根据词的权重值,采用空间限量模型算计算文档相关度得分
        设置Boost影响打分结果
Lucene:一个索引与搜索类库,并不是完整的程序
Solr:采用java5开发,高性能基于ucene的一个独立的企业级搜索应用服务器,对外提供web-service的接口
两者本质区别:solr是程序,而Lucene不是;lucene专注于搜索底层的建设,而solr专注于企业应用;Lucene不负责支撑搜索服务所必须的管理,solr负责;Solr是Lucene面向企业搜索应用的扩展
Solr:基于HTTP和Lucene;
        定制Solr索引的实现方法:使用post方法向Solr服务器发送一个描述所有field机器内容的xml文档就可以了.
        定制搜索的实现方法:发送HTTP GET请求即可,然后对Solr返回的信息进行重新布局;
    原理:
        服务原理:
            对外提供标准的http接口来实现对数据的索引的增删改查
            用户通过向部署在Servlet容器中的SolrWeb应用程序发送http请求来启动索引和搜索;
            Solr接受请求,确定要使用的适当的SolrRequestHandler,然后处理请求.通过Http以同样的方式返回响应;
            默认配置返回的Solr标准XML响应,也可以配置Solr的备用响应格式;
        索引原理:
            可以向Solr索引Servlet传递四个不同的索引请求:
            1)add/update允许向Solr添加文档或者更新文档.直到提交后才能搜索到这些添加和更新;
            2)commit告诉Solr应该使上一次提交以来所做的所有更改都可以都索道;
            3)optimize 重构Lucne的文件以改进搜索性能.索引完成后执行一下优化通常比较好.如果更新比较平凡,则应该在使用频率较低的时候安排优化
            一个索引无需优化也可以正常的运行,优化耗时;
            4)delete 按id或查询来指定,删除具有指定Id的文档;按查询删除将删除查询返回的所有文档;
        搜索原理:
        调用搜索接口select发送http get请求;
solr后台操作数据:
    更新是完全重新添加,并不是更新字段;不会叠加;
    使用dataimport批量导入数据;
Tomcat7上配置Solr:solrhome的配置; etc下包的引入

solr的使用,配置到tomcat之后,随着tomcat的启动启动solr查询的服务器,自定义字段都会在SolrCore中配置,直接在dao层调用就可以了!其他的和之前的是一样的!
    
项目的web.xml文件中的一个叫<distributable/>的标签通俗的将是为了告诉servlet容器,编写的讲师网站,是服务器进行session复制时必须的标签;
    
    
    
    
    
    
    
    
    
    
    
    
    
    
Jstl中<c:foreach>中varstatus的具体信息:
    不论是对整数还是对集合进行迭代,<c:forEach>的varStatus属性所起的作用相同。和var属性一样,varStatus用于创建限定了作用域的变量(改变量只在当前标签体内起作用)。不过,由varStatus属性命名的变量并不存储当前索引值或当前元素,而是赋予javax.servlet.jsp.jstl.core.LoopTagStatus类的实例。该类包含了一系列的特性,它们描述了迭代的当前状态,如下这些属性的含义如下所示:
            1.current:当前这次迭代的(集合中的)项。
            2.index:当前这次迭代从0开始的迭代索引。
            3.count:当前这次迭代从1开始的迭代计数。
            4.first:用来表明当前这轮迭代是否为第一次迭代,该属性为boolean类型。
            5.last:用来表明当前这轮迭代是否为最后一次迭代,该属性为boolean类型。
            6.begin:begin属性的值。
            7.end:end属性的值
            8.step:step属性的值

    
    
    
    
    
    
前端:
    1.radio和checkbox(checked)的默认被选中和select(selected)下拉框是不一样的;    
    2.将JS代码融入到html代码中:前面加javascript:
    3.通过一个按钮,控制页面后退    使用javascript:history.go(-1)  原页面表单的内容丢失
                   返回前一个页面  使用javascript:history.back(-1) 原页面表单中的内容不丢失
    4.jQuery比较适合互联网应用
       extJs适合做后台管理系统
       jQuery2.0之后不支持IE6以上,使用的JQuery1.4.2较多;
    5.单独选择子标签无后代 $("body>div")
    6.jQuery的加载时机优先于原声的JS,语法习惯符合java程序员的习惯,对象.方法(0);
    7.remove:删除节点
      empty:清空节点
mysql:
    1.一般使用隐式内连接,都是先产生笛卡尔积再清除,不适合大量数据
    2.外链接适合大量数据,选择数据量小的表为基准表,然后连接关联表
    3.执行顺序
        1、from 表名       把硬盘上的数据表读取到内存中.形成一张伪表
        2、where 条件      对伪表进行筛选和运算
        3、group by 字段    对伪表进行划分组(运算区)操作
        4、having  条件     对每一组(运算区)进行分别的运算
        5、select 字段       把每个一组(运算区)进行拼接,拼接成一张新伪表
        6、order by 字段     对新伪表进行排序
        7、limit             只获取伪表上的某些数据
    4.一对一可以合并成一张表,但是数据量大的时候,建议拆分成一对一
    5.能拆分成条件的一定不要用and,会导致查询的数据不准确
    6.tomcat内置连接池管理
       tomcat内置连接池使用的是dbcp。
        问题1:tomcat怎样管理连接池?(配置)
            要想将一个dbcp连接池让 tomcat管理,只需要创建一个context.xml配置文件,在配置文件中
            配置相关信息,
            <Context>
              <Resource name="jdbc/EmployeeDB" auth="Container"
                        type="javax.sql.DataSource" username="root" password="abc"
                        driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql:///day18"
                        maxActive="8" maxIdle="4"/>
            </Context>
            // Resource name="jdbc/EmployeeDB"   给这个连接起了一个名字,可以自定义
            问题:context.xml文件位置:
                1.在tomcat/conf/context.xml     这时这个连接池是给整个服务器使用的。
                2.在tomcat/conf/Catalina/localhost 这时这个连接池只给localhost虚拟主机使用。
                3.将context.xml文件放置在web应用的META-INF下
                注意:如果是全局设置,那么我们需要将数据库驱动放置在tomcat/lib目录下
            问题2:怎样从tomcat中获取连接池?
             我们在servlet中获取连接池对象。
            Context context = new InitialContext();
            Context envCtx = (Context)context.lookup("java:comp/env"); 固定路径
            DataSource datasource = (DataSource) envCtx.lookup("jdbc/EmployeeDB");  //和xml中一致就可以
            Connection con = datasource.getConnection();
XML:
    1.对于XML标签中出现的所有空格和换行,XML解析程序都会当作标签内容进行处理。    
    2.注释不可以嵌套
    3.&开头  ;结尾的均为特殊字符
    4.    <![CDATA[   内容(被当成字符串)   ]]>  CDATA区
    5.xml中注释不能嵌套
    6.schema技术:符合xml须发结构,可以解析schema文档,对命名空间的支持比较好,支持更多的数据类型,并且支持自定义的数据类型;
JMC命令:java自己的控制台!    
    
数据库表:横表和纵表
    1.横表:表的普通构建方式,适合不容易改动的表
        缺点:增加字段需要重新构件表结构;
        有点:清晰可见;
    2.纵表:主键-字段代码-字段值;特点是行数多,字段少;长表,经常改动不确定的表;
         缺点:不清晰,分组统计很繁琐;
         优点:修改字段效率高;
    3.互相转换:
阿里的Druid是一个JDBC组件,包括三部分:
    1.DruidDriver  代理Driver,能够提供基于Filter-chain模式的插件体系;
    2.DruidDataSource 高效可管理的连接池;
    3.SQLParser

    适合于电商类型的互联网项目:
    1.内置了一个statFilter,可以监控并统计SQL的执行性能,对于线上分析数据库访问性能有帮助;
    2.替换DBCP和C3PO,高效功能强大拓展性好的数据库连接池
    3.数据库密码加密;
        找到包执行命令Java -cp druid-0.2.23.jar com.alibaba.druid.filter.config.ConfigTools 123456
        得到的密文可以直接写到properties文件中;
    4.sql执行日志:支持一般的日志插件
    5.可以利用Druid提供的Filter-Chain机制编写JDBC的扩展插件
    
缓存:
    1.Spirng的缓存:
    2.Radis缓存:    
    
    
  -04-24
    1.SOA开发的概述
        可扩展,面向服务开发,维护型号,高聚合,低耦合,单一职责;
        两个web工程之间的相互调用;可以使用webService实现;Dubbo的好处在哪里 ?
    2.项目的环境搭建
        搞清楚依赖关系;
        公共类放在最外层,按调用度逐级向下;
depandencyManagement  不强制依赖  dependencies 强制以来
  -04-25
    1.DUBBO:基于二进制序列化的分布式服务框架,提高性能和透明化RPC远程服务调用方案;
        互联网项目应用框架:
                1.单一应用架构:流量小,all in one 降低部署成本和节点;数据访问框架(ORM)是关键!
                2.垂直应用结构:访问量增大,单一应用增加(服务器)带来的加速度越来越小,拆分成几个;(加速前段开发的MVC是关键);
                3.分布式服务架构:将核心业务(!!!!!!!!!!!)抽取作为独立的服务,形成服务中心;提高业务服用及整合的分布式服务框架(RPC)是关键.
                4.流动计算框架:服务太多,形成一个调度中心基于访问压力实施管理集群容量,提高利用率;提高机器利用率的资源调度和治理中心(SOA)是关键.
        服务器(Container)启动,加载服务提供者(provider,提供服务到注册中心),服务提供者向注册中心(registory,使用zookeeper)提供自己的服务,消费者(consumer,调用方)启动时,向注册中心订阅需要的服务
    注册中心返回提供方的地址列表,如有变动,注册中心将基于长连接推送变更数据给消费者。服务消费者,从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一台调用;
    监控中心(monitor):统计两者在内存中的调用时间和次数;    
    pojo需要实现序列化接口;
    2.RPC跨服务器调用并返回结果,隐藏通讯细节;
        hessian:采用Http通讯,Servlet暴露服务,传入传出参数数据包较大,提供者比消费者个数多,提供者大力较大,可传文件;
        dubbo:采用单一长连接和NIO异步通讯,小数据量大并发的服务调用,以及服务消费者远远大于服务提供者的情况
        




TCP连接的分类
    短连接:正常三次握手产生的连接,双方读写完毕之后释放;
    长连接:与正常三次握手产生的短连接区别,短连接在servr和client双方读写完毕之后释放,长连接不会,将继续被后续的读写使用

  -04-26
1.安装zookeeper注册中心:
    1.进入解压目录创建data文件;
        创建多级目录 使用 makdir -p
    2.mv 同级目录的移动相当于改名!
    shift zz 保存并推出当前编辑文件;
2.zookeeper的优化配置:
    1.zookeeper的直连:将自己作为注册中心对外提供
        1.在提供方配置直连和自定义dubbo协议
        2.在消费方配置直连,引用添加url    
    2.消费方的全局超时市时间;
3.Junit不支持多线程测试    

遇到的问题:1.junit测试不能自动注入service
           2.dubbo传输的时候数据量太大(看下传输原理)
           3.jstl版本问题会影响jsp页面的解析    
           4.配置上传解析器时的name必须是multipartResolver
           5.字段一致问题
  -04-28
    FastDFS:
        概念:轻量级的分布式文件系统
            tracker server:跟踪服务器,调度服务器,访问上起负载均衡的作用.记录storage server的状态,是间接Client和storage server的枢纽
            storage server:存储服务器(存储节点或数据服务器),文件和meta data 都保存在该服务器上
                    提高单个节点的性能,提高整个项目APP的性能;
                    数据的操作容器容量越小效率越高;
            group(volume):组,也可以成为卷,group是相对storage server而言的,即资源存放地,一组可以有多个storage server ,数据相互备份;同组内的服务器上的文件是相同的;
                        
            meta data :文件的相关属性,是一个键值对的列表
            client:通过提供的接口,使用TCP/IP协议跟与踪服务器或者存储服务器进行数据交互
        优点:备份功能,分布式服务器,不存在单点故障,支持扩容(网络磁盘挂载--与其他服务器共享资源)
        功能:管理文件;存储,同步,文件访问(上传下载等),解决大容量存储和负载均衡问题;
        使用场景:适合以文件为载体的在线服务;
  -05-04
    1.上传多个文件:使用mutiple属性    
    2.初始化参数:@RequestParam
    3.kindeditor:开源的html可视化编辑器,用户在网站上实现文本编辑器中编辑私有格式的内容;
                引入框架的js和中文语言包;
                --将textarea渲染成富文本编辑器;
                create(textarea的对象,内容)
                --将富文本编辑器转换为textarea,为表单提交
                sync方法;
    4.Jedis:
      JedisPool:
      JedisCluster:集群
  -05-05
    1.linux上搭建solr服务
    2.IK分词器的配置
    3.配置停用词和扩展词


  -05-06
    jsp页面判断集合是否为空 fn:length(集合名称)
    java NIO:(java new IO)jdk1.4中的新的API,为所有的原始的读写提供魂村支持,字符编码解码解决方案.
              Channels:从通道中读取;
              Buffers:读取到缓冲区中;
              Selectors:选择器用于箭筒多个通道时间.单个线程可以箭筒多个数据通道;
              Non-blocking IO(非阻塞IO):在数据读写的同时,可以做其他事情;非阻塞的使用IO


    ActiveMQ消息队列:消息传输过程中保存消息的容器;
        点对点模式(p2p):指定消费,发布的消息只能被指定客户消费一次,消费之后会消失;
        订阅/发布模式(主题模式):发布的消息可以被所有订阅的用户消费;
    weakHashmap继承自Hashmap:如果内部的key除了自身之外没有其他引用,会自动丢弃此值;
  -05-08
    1.FreeMaker:模板引擎;模板加数据=显示的jsp;
  -05-10
    1.encodingURIComponent:对特殊字符进行编码;
    2.poi支持2003或者2007版本的excls表格;
    3.ajax同步和异步只差一个async属性
    4.jquery轻量级的js库,解决浏览器兼容问题,
    5.用户信息放到session中的安全隐患,url中加上sessionid之后,其他用户登录成功之后,造成两个用户公用一个sessionid,导致信息泄露;
    6.cookie的跨域问题,秩序要设置一个p3p头即可,可以解除浏览器对cookie的写阻止;
    7.ArrayList的默认长度是10
    8.


1.Thread类的方法有start、run、getPriority;
2.关系型数据库:Orcle,Mysql,DB2
  非关系型数据库:MonggoDB、memcacheddb、Redis等
  层次数据库:IMS(Information Management System)层次数据库
3.线程分为守护线程和非守护线程;守护线程守护非守护线程的运行,只有最后一个非守护线程结束之后,守护线程才会和JVM一起结束工作!守护线程的最典型应用就是GC(
垃圾回收器)
4.volatile是一个类型修饰符,被设计用来修饰被不同线程访问和修改的变量.使用volatile修饰的变量,每次线程运行的时候都会重新从主存中读取此变量的值;当变量发生变化的时候,会强制将变化之后的值写入到主存中去;所以不能保证线程安全
5.基本类型的最值是存在类型问题的基本例子; i+1<i;
6.ArrayList的默认长度是10;
7.常用的对称加密算法有:DES、3DES、RC2、RC4、AES
  常用的非对称加密算法有:RSA、DSA、ECC
  使用单向散列函数的加密算法:MD5、SHA
8.null值可以被转为任意java类型,但强转后的对象的是无效对象,不能调用和对象有关的非静态方法;
9.静态代码块永远先执行,然后是代码块,然后是构造方法,在创建子类对象的时候会执行父类的构造方法;
10.catch捕获异常是按顺序捕获的,应该讲最大的expection放在最后!
11.使用transient修饰的词不能被序列化,static修饰的不能被序列化!
12.dubbo中间件为防止调用不到服务,测试设置timeout,将业务代码全部放到服务层,不要在调用层多写其他的代码!
13.activeMQ消息队列如果消费方接受不到消息,默认是两次重发,可以设置发送超时避免两次之后无限发送!


512646723
SpringBoot笔记:
    1.将jar包导入即可,推荐使用maven!
    2.Groovy是一种基于JVM(java虚拟机)的敏捷开发语言,结合了Pathon、Ruby和Smalltalk的许多强大特性!能与java代码很好的结合,用于扩展现有代码,可以使用其他java语言编写的类库!
    3.Gradle 是以 Groovy 语言为基础,面向Java应用为主.基于DSL(领域特定语言)语法的自动化构建工具。约定大于配置,
    4.CLI(command-line interface,命令行界面)
    5.GVM(Gorrvy环境管理器),可以用来管理不同版本的Groocy和Java二进制包;
    



Zookeeper-cluster:
    1.创建放置多个zookeeper的目录
    2.解压到该目录下,并修改文件夹的名称
    3.创建data和logs文件夹存放数据和日志
    4.将zoo_sample.cfg文件修改为zoo.cfg文件
    5.修改上面的文件,指定data目录和logs目录,指定zookeeper的节点编号
    6.注意ClientPort,在data下创建myid文件,指定是第几个节点
    7.复制好三个,修改以上文件的目录,和端口号,一次启动,报错不必理会





  .06.05
异常记录:Plugin execution not covered by lifecycle configuration: 配置插件延迟加载
  .06.07
datax:是一种异构数据源之间的数据迁移的高效工具;
针对离线数据量很大,表非常多的时候,可以由脚本批量生成配置文件,增大DataX的并发量,提高任务机的数量
Sqoop:主要用于在HADOOP(Hive)与传统的数据库之间的数据传递,可以将一个关系型数据库中的数据导进到Hadoop的HDFS中,也可已进行逆向导进;
Kettle:一款国外开源的ETL工具,纯Java编写,可以在Windows、Linux、Unix上运行,数据抽取高效稳定;
  .06.08
线程池:池化资源,相对灵活,减少资源损耗,提高效率;   
newCachedThreadPool:可以缓存线程,创建最大线程数根据内存决定,自动回收空闲线程,可以创建所需的新线程;
                    适用于短周期异步任务;
newFixedThreadPool:固定大小的线程池,最大值被规定,一旦线程因为异常执行结束,会创建所需的新线程;
                       适用于长周期的异步任务,稳定,波动性小,防止线程无限制增长;
newScheduleThreadPool:该线程支持定时或周期的执行任务;
                    适用于周期定时执行任务
newSingleThreadExecutor:创建一个单线程,一旦异常结束,会有新的线程代替,将提交的任务排队执行;    
                    适用于按顺序的串行执行任务,考虑到线程阻塞,会创建新线程                
阻塞队列:
1.ArrayBlockingQueue:基于FIFO的有界队列,不可扩容
2.LinkedBlockingQueue:基于FIFO的有界队列,当容量设为int最大值时认为是无界,不可扩容,用于实现FixedThreadPool、SingleThreadExecutor
3.SynchronousQueue:没有容量的队列,俗称同步队列,实现CachedThreadPool
4.DelayedWordQueue:基于优先级的无界队列,可扩容,用于实现ScheduleThreadPool

  .06.09
1.javax.crypto.BadPaddingException: Given final block not properly padded;
      在用DES加密的时候,最后一位不足64的,会自动补全至64,在尽心字节数组到字符串的转化过程中,把它填补的不可见字符改变了,所以引发系统抛出异常!
      如果加密和解密使用的秘钥不相同也会报错!
  .06.10
1.Kibana:是一个为Logstash和ElasticSearch提供的日志分析的Web接口.搜索,可视化,分析日志
    环境要求:
        ruby >= 1.8.7 (probably?)
        bundler
        logstash >= 1.1.0
        elasticsearch >= 0.18.0
2.Jenkins
    开源软件项目, 使得软件的持续集成变成可能;连接多台服务器或者计算机一起测试;查看日志,请求和响应参数等;
  .06.12
1.web.xml 的加载顺序是:[context-param -> listener -> filter -> servlet -> spring]
2.集群实现高可用的时候出现的脑裂:
"Split brain" is a condition whereby two or more computers or groups of computers lose contact with one another but still act as if the cluster were intact. This is like having two governments trying to rule the same country. If multiple computers are allowed to write to the same file system without knowledge of what the other nodes are doing, it will quickly lead to data corruption and other serious problems.
Split-brain is prevented by enforcing quorum rules (which say that no group of nodes may operate unless they are in contact with a majority of all nodes) and fencing (which makes sure nodes outside of the quorum are prevented from interfering with the cluster).
在“双机热备”高可用(HA)系统中,当联系2个节点的“心跳线”断开时,本来为一整体、动作协调的HA系统,就分裂成为2个独立的个体。由于相互失去了联系,都以为是对方出了故障,2个节点上的HA软件像“裂脑人”一样,“本能”地争抢“共享资源”、争起“应用服务”,就会发生严重后果:或者共享资源被瓜分、2边“服务”都起不来了;或者2边“服务”都起来了,但同时读写“共享存储”,导致数据损坏(常见如数据库轮询着的联机日志出错)。
!!为了避免出现脑裂,可采用下面的预防措施:
添加冗余的心跳线,例如双线条线。尽量减少“裂脑”发生机会。
启用磁盘锁。正在服务一方锁住共享磁盘,“裂脑”发生时,让对方完全“抢不走”共享磁盘资源。但使用锁磁盘也会有一个不小的问题,如果占用共享盘的一方不主动“解锁”,另一方就永远得不到共享磁盘。现实中假如服务节点突然死机或崩溃,就不可能执行解锁命令。后备节点也就接管不了共享资源和应用服务。于是有人在HA中设计了“智能”锁。即,正在服务的一方只在发现心跳线全部断开(察觉不到对端)时才启用磁盘锁。平时就不上锁了。
设置仲裁机制。例如设置参考IP(如网关IP),当心跳线完全断开时,2个节点都各自ping一下 参考IP,不通则表明断点就出在本端,不仅“心跳”、还兼对外“服务”的本端网络链路断了,即使启动(或继续)应用服务也没有用了,那就主动放弃竞争,让能够ping通参考IP的一端去起服务。更保险一些,ping不通参考IP的一方干脆就自我重启,以彻底释放有可能还占用着的那些共享资源。

  .06.13
    Regex Match Tracer:正则表达式便携工具
    VBA:宏命令
    Sed:
    命令始终是这个格式:sed [options] 'command' file(s)
                       sed [options] -f scriptfile file(s)
    AWK:
        命令始终是这个格式:awk '{pattern + action}' 或者 awk 'pattern {action}';
                                pattern:要查找的内容
                                action:查找内容时执行的动作;
  .06.14
    Kafka:高吞吐量的分布式发布订阅消息系统;
        1.通过IO的磁盘数据结构提供消息的持久化,这种结构对于即使数以TB的消息存储也能够保持长时间的稳定性能。
        2.高吞吐量:即使是非常普通的硬件Kafka也可以支持每秒数百万的消息。
        3.支持通过Kafka服务器和消费机集群来分区消息。
        4.支持Hadoop并行数据加载。
        Broker
    Kafka集群包含一个或多个服务器,这种服务器被称为broker[5]
    Topic
    每条发布到Kafka集群的消息都有一个类别,这个类别被称为Topic。(物理上不同Topic的消息分开存储,逻辑上一个Topic的消息虽然保存于一个或多个broker上但用户只需指定消息的Topic即可生产或消费数据而不必关心数据存于何处)
    Partition
    Partition是物理上的概念,每个Topic包含一个或多个Partition.
    Producer
    负责发布消息到Kafka broker
    Consumer
    消息消费者,向Kafka broker读取消息的客户端。
    Consumer Group
    每个Consumer属于一个特定的Consumer Group(可为每个Consumer指定group name,若不指定group name则属于默认的group)。
  .06.23
YAML是"YAML Ain't a Markup Language"(YAML不是一种置标语言)的递回缩写。在开发的这种语言时,YAML 的意思其实是:"Yet Another Markup Language"(仍是一种置标语言),但为了强调这种语言以数据做为中心,而不是以置标语言为重点,而用返璞词重新命名。

YML文件格式是YAML (YAML Aint Markup Language)编写的文件格式,YAML是一种直观的能够被电脑识别的的数据数据序列化格式,并且容易被人类阅读,容易和脚本语言交互的,可以被支持YAML库的不同的编程语言程序导入,比如: C/C++, Ruby, Python, Java, Perl, C#, PHP等。
        格式:spring:
                 application:
                 name: foo
                 cloud:
                 config:
                   uri: ${SPRING_CONFIG_URI:http://localhost:8888}
               相隔两个字符来表示父子关系
    SpringCloud:为开发人员提供了快速构建分布式系统中一些常见模式的工具(例如配置管理,服务发现,断路器,智能路由,微代理,控制总线)
    
  .06.26
    Zabbix:
            zabbix(音同 zæbix)是一个基于WEB界面的提供分布式系统监视以及网络监视功能的企业级的开源解决方案。
            zabbix能监视各种网络参数,保证服务器系统的安全运营;并提供灵活的通知机制以让系统管理员快速定位/解决存在的各种问题。
            zabbix由2部分构成,zabbix server与可选组件zabbix agent。
            zabbix server可以通过SNMP,zabbix agent,ping,端口监视等方法提供对远程服务器/网络状态的监视,数据收集等功能,它可以运行在Linux,Solaris,HP-UX,AIX,Free BSD,Open BSD,OS X等平台上。
    测试工具:
            MOCK:对某些不容易构造或者不容易获得的对象,使用一个虚拟的对象来创建;
            使用powermock的@PrepairForTest;
        使用步骤:1.导包
            <dependency>  
                <groupId>org.powermock</groupId>  
                <artifactId>powermock-api-mockito</artifactId>  
                <version>1.6.6</version>  
            </dependency>   
            <dependency>  
                <groupId>org.mockito</groupId>  
                <artifactId>mockito-all</artifactId>  
                <version>1.10.19</version>  
            </dependency>  
            <dependency>  
                <groupId>org.powermock</groupId>  
                <artifactId>powermock-module-junit4</artifactId>  
                <version>1.6.6</version>  
                <scope>test</scope>  
            </dependency>  
            <dependency>  
                <groupId>org.powermock</groupId>  
                <artifactId>powermock-module-junit4-rule-agent</artifactId>  
                <version>1.6.6</version>  
                <scope>test</scope>  
            </dependency>  
            <dependency>  
                <groupId>org.powermock</groupId>  
                <artifactId>powermock-module-junit4-rule</artifactId>  
                <version>1.6.6</version>  
                <scope>test</scope>  
            </dependency>  
            <dependency>  
                <groupId>org.jacoco</groupId>  
                <artifactId>org.jacoco.agent</artifactId>  
                <classifier>runtime</classifier>  
                <version>0.7.9</version>  
                <scope>test</scope>  
            </dependency>
            2.如果直接使用Spring的Runner(SpringJUnit4ClassRunner)就无法使用mock的Runner(PowerMockRuner);正确使用方式如下
                @PowerMockIgnore({"java.lang.management.*","javax.management.*","javax.xml.*","org.xml.sax.*","org.apache.xerces.*","org.w3c.*"})  
                @RunWith(PowerMockRunner.class)  
                @PowerMockRunnerDelegate(SpringJUnit4ClassRunner.class)  
                @ContextConfiguration(locations = "classpath:META-INF/spring/test-spring.xml")
                classpath:META-INF/spring/test-spring.xml 是单元测试专门的spring配置文件,和域代码使用的配置有些不同。这个文件我放在/test/resources/spring/目录下。本文件中没有Dubbo的配置
            3.利用Spring的Bean注入启动
            4.在测试的时候利用Spring的两个测试类,可以得到目标类的代理对象,就可以进行反射注入
            org.springframework.test.util.AopTestUtils;  
            org.springframework.test.util.ReflectionTestUtils;
            jacoco:覆盖率测试工具;
  .06.28:
    JVM问题:
        JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,
    设计模式:
        1.工厂模式(Factory Method):
            1.1 普通工厂模式:通过传递字符串在一个方法内判断然后返回对象;
            1.2 多个工厂方法:多个方法分别创建多个对象;
            1.3 静态工厂模式:静态方法创建对象,直接调用;
        2.抽象工厂模式(Abstract Factory):
            增加程序的拓展性和Java的解耦原则,将工厂类抽取出接口来
        3.单例模式(Singleton):
            普通的单例模式涉及线程安全问题;
            普通单利的问题
                !!在Java指令中创建对象和赋值操作是分开进行的,也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序,也就是说有可能JVM会为新的Singleton实例分配空间,然后直接赋值给instance成员,然后再去初始化这个Singleton实例。
            相对完美的单例模式两种
                3.1 使用内部类维护                
                        public class Singleton {  
                          
                            /* 私有构造方法,防止被实例化 */  
                            private Singleton() {  
                            }  
                          
                            /* 此处使用一个内部类来维护单例 */  
                            private static class SingletonFactory {  
                                private static Singleton instance = new Singleton();  
                            }  
                          
                            /* 获取实例 */  
                            public static Singleton getInstance() {  
                                return SingletonFactory.instance;  
                            }  
                          
                            /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */  
                            public Object readResolve() {  
                                return getInstance();  
                            }  
                        }  
                3.2 分离new 和getinStance方法 使用Synchronized 锁住 new;
                         public class Singleton{
                             private static Singleton instance =null;
                             private Singleton(){

                             }

                             private static synchronized void syncInit(){
                                 if(instance ==null){
                                      instance =new Singleton();
                                 }
                             }

                             public static Singleton getInstance(){
                                 if(instance ==null) {
                                     syncInit();
                                 }
                                 return  instance;
                             }
                         }
            影子实例为单利对象的属性同步更新:    
                        public class SingletonTest {  
                          
                            private static SingletonTest instance = null;  
                            private Vector properties = null;  
                          
                            public Vector getProperties() {  
                                return properties;  
                            }  
                          
                            private SingletonTest() {  
                            }  
                          
                            private static synchronized void syncInit() {  
                                if (instance == null) {  
                                    instance = new SingletonTest();  
                                }  
                            }  
                          
                            public static SingletonTest getInstance() {  
                                if (instance == null) {  
                                    syncInit();  
                                }  
                                return instance;  
                            }  
                          
                            public void updateProperties() {  
                                SingletonTest shadow = new SingletonTest();  
                                properties = shadow.getProperties();  
                            }  
                        }  
        4.建造者模式(Builder):
            创建多个对象,或者是对象的集合;
        5.原型模式(Prototype):
            将一个对象作为原型,使用clone方法进行复制:
            A对象引用B  B=new B(1,2); C是A的克隆
            浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的。
            C中的B=B(1,2);
            深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。
            C中的B=new B();    
            两种复制的代码实现:        
            public class Prototype implements Cloneable, Serializable {  
              
                private static final long serialVersionUID = 1L;  
                private String string;  
              
                private SerializableObject obj;  
              
                /* 浅复制 */  
                public Object clone() throws CloneNotSupportedException {  
                    Prototype proto = (Prototype) super.clone();  
                    return proto;  
                }  
              
                /* 深复制 */  
                public Object deepClone() throws IOException, ClassNotFoundException {  

                    /* 写入当前对象的二进制流 */  
                    ByteArrayOutputStream bos = new ByteArrayOutputStream();  
                    ObjectOutputStream oos = new ObjectOutputStream(bos);  
                    oos.writeObject(this);  
              
                    /* 读出二进制流产生的新对象 */  
                    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
                    ObjectInputStream ois = new ObjectInputStream(bis);  
                    return ois.readObject();  
                }  
              
                public String getString() {  
                    return string;  
                }  
              
                public void setString(String string) {  
                    this.string = string;  
                }  
              
                public SerializableObject getObj() {  
                    return obj;  
                }  
              
                public void setObj(SerializableObject obj) {  
                    this.obj = obj;  
                }  
              
            }  
              
            class SerializableObject implements Serializable {  
                private static final long serialVersionUID = 1L;  
            }  

        6.适配器模式(Adapter)
            1.类的适配器模式:接口A想拥有接口B中的同名方法的功能,一个中间类集成B实现A,创建A的对象就能调用B的方法;
            2.对象的适配器模式:将目标方法的对象作为参数传递到适配器类(已继承接口)中,调用方法;
            3.接口的适配器模式:将实现接口必须实现方法通过增加一个中间类来达到只重写目标方法的功能
        7.装饰者模式(Decorator)
            装饰对象必须持有被装饰对象的实例,实现统一接口,被装饰者可以是这个借口,由装饰者实现;装饰者模式将对象直接传参到构造方法;
        8.代理模式(Proxy)
             创建一个代理类,持有要代理对象,然后实现公共借口,类似装饰者;但是,代理模式是控制对对象的访问;
        9.外观模式(Facade)
              将多个类的关系放到一个类中,使之不产生依赖关系,达到解耦的效果;
        10.桥接模式(Bridge)
               通过对接口的调用,实现对实现类方法的调用;一般模式都是将要调用的方法的对象私有化或者传参构造方法;
        11.组合模式(Composite)
               父子对象,相互持有,常用于树形结构中;
        12.享元模式(Flyweight)
               池化资源,连接池为例;同一对象创建多次,共享属性!!
        13.策略模式(Strategy)
               将公用方法放到抽象类中,类名相同但是内容不同的方法可以抽取到接口中,然后继承抽象类,实现接口,进行方法调用.
        14.模板方法模式(Template Method)
               抽象类,含有公共主方法和公共调用方法和抽象的需要实现的不同方法,子类继承这个抽象类,实现抽象方法,即可进行调用;
        15.观察者模式(Observer)
               发布/订阅模式;A发布信息,持有接受信息的类的列表,当A的信息的状态改变的时候,影响接受信息的类的状态;
        16.迭代子模式(Itertor)
               去看集合的遍历;
        17.责任链模式(Chain Of Responsibility)    
                Struts2的拦截器就是这么实现的,在同一时刻,命令只允许有一个对象传给另一个对象,而不是多个对象!
        18.命令模式(Command)
                通过将对象作为传递参数来实现解耦,通过中间对象取得实现调用关系;
        19.备忘录模式(Memento)
                 一个原始类,一个备忘录类,一个存储备忘录的类,为毛要把备忘录存储起来?两个类就可以解决
        20.状态模式(State)
                 不同的角色对应不同的功能;
        21.访问者模式(Visitor)
            
                




               










区块链:是分布式数据存储、点对点传输、共识机制(区块链系统中实现不同节点建立信任、获取权益的数学算法)、加密算法等计算机技术的新的应用模式.
  .07.03
    Jetty:可以嵌入java程序中做开发,架构简单,主要通过Handler实现,易于拓展,可以同时处理大量连接而且可以长时间保持连接,适合于web聊天应用等等。架构简单,因此作为服务器,可以按需加载组件,减少不需要的组件,减少了服务器内存开销,从而提高服务器性能。jetty的应用更加快速,修改简单,对新的Servlet规范的支持较好。默认采用NIO结束在处理I/O请求上更占优势,在处理静态资源时,性能较高
    Tomcat:不以拓展,适合处理少数繁忙的短连接,默认采用BIO处理I/O请求,在处理静态资源时,性能较差。
  .07.05
    ico是Icon file的缩写,一般的比较大点的软件都有个ICO文件就象网站的LOGO 一样,如果ico文件的分辨率过大,windows7 的图片管理器可以打开,也可以直接使用系统自带的缩略图来或者ACDSee预览ico文件,如果要编辑的话可以使用IconCool Editor等其他图标制作工具。
  .07.07
HTTP缓存:就是一种约定,通过设置不同的响应头Cache-Control来控制浏览器和Web代理对缓存的使用策略,通过设置请求头If-None-Match和响应头Etag,来对缓存的有效性进行验证;
1.响应头 ETag:Entity Tag,可以使资源的Hash值或者是版本号,反映资源变化,是Http缓存正常工作的基础.
2.请求头 If-None-Match:带有资源的版本信息,发送到服务器与服务器中的版本比较,若有更新,使用ETag,没有更新返回304,标识缓存有效;
3.响应头 Cache-Control:定义缓存策略,取代Expires,浏览器都支持;
    max-age:
    public(默认)和private:区别是中继的web代理是否可以缓存;
    no-cache:使用缓存资源之前必须和服务器确认;
    no-store:不缓存
  .07.10
Require.js:
    1. 实现js的异步加载,避免网页失去响应
    2. 管理模块之间的依赖,便于代码的编写和维护
使用方法:
    1.加载require.js文件(可以写在页面最后,也可以如下方式,只要实现不影响页面加载即可)
      <script src="js/require.js" defer async="true" ></script>
    2.解决模块之间的相互依赖,加载一个入口js依赖所有需要加载的模块,使用
    require([a,b,c],function(a,b,c){
            依赖模块(目录一致)  加载完成后执行的回调函数,可以使用参数
    })
    3.使用require.config()可以指定目录
    4.require.js加载的模块,采用AMD规范,使用define定义函数,如果没有依赖直接定义,如果有依赖,define的第一个函数必须标明依赖;

    AMD规范:即使用define定义函数:
        define([模块标识,可省],[所依赖模块,可省可配插件],本身实现);
        仅有一个函数的define(函数可以使js对象,也可以是函数):
            1.对象:包含方法具有功能的对象,或者是只提供数据;
                    define({
                                provinces: [
                                {
                                name: '上海名',
                                areas: ['浦东新区', '徐汇区']},
                            });
            2.提供数据;
                        define(function(){
                                var p = require('china');
                                //使用china这个模块
                                });
            省略模块名可以很灵活的依赖所需要的模块,define方法在执行的时候,会调用函数的toString方法,扫描require调用,提前加载模块;            
    5.调用的时候采用模块名.内部方法来实现;
    6.加载非ADM规范的js库:
        require.config({
            shim(配置不兼容模块):{
                'underscore':{
                    exports(模块外部调用时所使用的名称):'_'
                },
                'backbone'(模块名):{
                    deps(依赖):['underscore','jquery'],
                    exports:'backbone'
                }
            }
        })
    7.require提供的插件:
        1.domread插件可以让回调函数在页面DOM结构加载完成后再运行;
        require(['domready!'], function (doc){
    });
        2.text和jimage插件,允许加载文本和图片文件
            define(['text!review.txt',
                'image!cat.jpg'],
                 function(review,cat){
                console.log(review);
               document.body.appendChild(cat);
            }
         );
  .07.11
关于JS的封装:
        使用call方法和apply方法,方法基本相同,区别是call的第二个参数可以是任意类型,但是apply的第二个参数智能是数组,不能为空;两者如果不提供对象,都使用Global对象,但是apply不能传递参数;相当于变相的继承;
  .08.03
        前端浏览器兼容问题:不同的浏览器因为内核不同,对同一段代码有不同的解析,造成页面不统一;

LaTeX
        LaTeX(LATEX,音译“拉泰赫”)是一种基于ΤΕΧ的排版系统,由美国计算机学家莱斯利·兰伯特(Leslie Lamport)在20世纪80年代初期开发,利用这种格式,即使使用者没有排版和程序设计的知识也可以充分发挥由TeX所提供的强大功能,能在几天,甚至几小时内生成很多具有书籍质量的印刷品。对于生成复杂表格和数学公式,这一点表现得尤为突出。因此它非常适用于生成高印刷质量的科技和数学类文档。这个系统同样适用于生成从简单的信件到完整书籍的所有其他种类的文档。

        目前没有一种工具可以取代LaTex的排版地位  下载地址 http://www.ctex.org/CTeXDownload

Pascal (结构化编程语言 )
        Pascal的名称是为了纪念十七世纪法国著名哲学家和数学家Blaise Pascal而来的,它由瑞士Niklaus Wirth教授于六十年代末设计并创立的。
        Pascal语言语法严谨,层次分明,程序易写,可读性强,是第一个结构化编程语言。
        Pascal计算机程序教程如今已经有专业化课程,并且越来越完善和严格化。
        Pascal有6个主要的版本,分别是Action Pascal Unextended Pascal、Extended Pascal、Object-Oriented Extensions to Pascal、Borland Pascal和Delphi Object Pascal。
        Pascal语言广泛用于各种软件,程序分为名称(program后自拟)、设置(var后规定)、开始(begin)、程序(正文)、读取(read/readln)、结束(end),结构层次强,严谨而又紧密。
  .08.15
    每秒处理的事务数(Transactions Per Second ,TPS),代表服务器每秒平均响应的请求数量,TPS与程序的并发能力有着非常密切的关系.
    存储设备与处理器的运算能力有几个数量级的差距,加入读写速度非常接近处理器运算速度的高速缓存(cache)来作为内存与处理器之间的缓冲,运算完毕之后同步到内存,涉及到内存一致性,使用协议(MSI,MESI,MOSI,Dragon Protocol);
    为使得运算单元被充分利用,处理器会对输入的代码进行乱起执行(Out-Of-Order-Execution)的优化,然后重组以保证程序的正确性;    
Java内存模型:
===执行===
    1.线程有自己的工作内存,对变量的读写不能直接写入主存中;主存与工作内存之间的交互,有八种方法操作:
        1.lock:标识为一条线程独占;-----主存
        2.unlock:释放锁定的变量;-----主存
        3.read:把变量值从主存传输到工作内存;-----主存
        4.load:将read得到的变量放入工作内存的变量副本中;-----工作内存
        5.use:将变量值传输给执行引擎,每当虚拟机遇到一个需要使用变量的值得字节码指令时执行;-----工作内存
        6.assign:当接收到赋值字节码指令的时候,将从工作引擎中接收到的值赋值给工作内存的变量;-----工作内存
        7.store:把工作内存中的一个变量传送到主内存中;-----工作内存
        8.write:把store操作的那个变量值传送到主内存变量中;-----主内存
    2.重排序:
        1.编译器优化:不改变单线程程序语义放入的前提下;
        2.指令级并行:现代处理器采用了指令级并行技术来将多条指令重叠执行.不存在数据依赖性,可以改变执行顺序;
        3.内存系统重排:
    3.为了保证内存的可见性,Java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。
    4.Java内存模型把内存屏障分为四种:
        Load Load:主存到工作内存
        StoreStore:工作内存到主存
        LoadStore:
        StoreLoad:
        确保之前所有的类型动作先于之后的类型动作执行!
    一个线程调用的方法和相关性信息被存储在栈中,栈就是本地
    所有创建的对象都存储在堆区,即使,调用方法的变量中有对象的引用,也只是在栈区存储对象的引用;
    对象的成员方法,如果包含本地变量 就会被存储在栈区,static修饰的都会被存储在堆区;

使用redis的时候,尽量是用hashGet/hashSet来存取,节约内存,通过hash来复用key,key和一个set集合代替和原来的键值对;

  .08.16
    RabbitMQ:


        问题:
            1.解决RabbitMQ队列超长QueueingConsumer导致JVM内存溢出的问题;
                合理的设置QoS参数;
  .08.18
    SVN合并代码并不是把多的加过来,还要把少的删掉;
  .09.08
    1.概念
    Shell脚本,运行在linux系统上类似于win上的cmd命令行;
        sh(Bourne Shell):是UNIX最初使用的shell,兼容性强,在shell变成方面强,在与用户的交互方面弱;
        bash(Bourne Again Shell):变成和交互都很优秀,继承了C Shell和Korn Shell的优点,强大而灵活的编辑接口;
        csh(C Shell):是一种比Bourne Shell更加适合的变种Shell,语法类似于C;
        Tcsh:C Shell的扩展版本,关系同上面两种Shell;
        ksh (全称 Korn Shell): 集合了 C Shell 和 Bourne Shell 的优点并且和 Bourne Shell 完全兼容。
        pdksh: 是 Linux 系统提供的 ksh 的扩展。
        pdksh 支持人物控制,可以在命令行上挂起,后台执行,唤醒或终止程序。
    2.语法   echo 后加内容 类似于日志打印
        变量的定义:变量名=值;中间不能有空格,使用时在前加美
        双引号中的内容可以被解释且替换掉,单引号中的内容被认为是普通的字符;
        双引号中可以出现双引号,但是单引号中不能出现单引号,即使转义;
        ${#string} string的长度;
        ${string:1:4} 从索引1开始向后四位
        echo `expr index "$string" is` 查找i或者s的位置;
        支持一维数组,没有大小,下标由0开始,定义数组用括号,分量用空格隔开;
        echo ${array_name[@]} 读取数组一般用下标,使用@会获取全部元素;
        ${var#*字符}从左边开始删除第一个匹配字符及左边所有的字符,##表示从左边开始删除最后一个匹配字符以及左边所有的字符;
        %从右边开始删除第一个匹配字符以及右边的所有字符;%%表示从右边开始删除最后一个匹配字符以及右边的所有字符;
    3.方法
        通过占位符传递参数;
        $#     传递到脚本的参数个数
        $*     以一个单字符串显示所有向脚本传递的参数。
        如"$*"用「"」括起来的情况、以"$1 $2 … $n"的形式输出所有参数。
        $$     脚本运行的当前进程ID号
        $!     后台运行的最后一个进程的ID号
        $@     与$*相同,但是使用时加引号,并在引号中返回每个参数。
        如"$@"用「"」括起来的情况、以"$1" "$2" … "$n" 的形式输出所有参数。
        $-     显示Shell使用的当前选项,与set命令功能相同。
        $?     显示最后命令的退出状态。0表示没有错误,其他任何值表明有错误。
    4.赋值的时候运算符号和变量之间必须用空格隔开;运算的时候等号和变量之间不能使用空格;乘号必须转义才能使用;


    JNA(Java Native Access)提供一组Jaba工具类用于在运行期间动态访问系统本地库(native library:如win的dll)而不需要编写任何 Native/JNI 代码.
    JNI(Java Native Interface)提供了若干的API实现了Java和其他语言的通信(主要是C和C++)。

Linux中的两种特殊文件:
    软连接:类似快捷方式,可以让快速链接到目标档案或目录         ln -s   source  target        
    硬链接:则投过文件系统的inode来产生新档名,而不是产生新档案  ln       source  target

HttpsClient发送http请求 需要将cookie去"secure"化,才可以发送;


  • 1
    点赞
  • 1
    评论
  • 3
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 精致技术 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值