2017-08-23

-JAVA

Spring笔记(一)

1.基本介绍

spring 是一个一站式框架，也就是有了它 web 层，service 层还有 dao 层都能直接搞定而不需使用其他的框架。
这三层分别就是：

SpringMVC
ioc
JdbcTemplate
Read More

2017-08-23

-JAVA

Struts2笔记(三)

拦截器，struts2方庄了很多功能，这些功能都是使用拦截器来实现的。一般的拦截器只是执行默认的拦截器，就是在struts-core这个包里面，然后李 main 有一个struts-default.xml这个文件李爱你就定义了很多默认的拦截器，interceptor-strck这个标签里面就是默认的拦截器。例如里面有ModelDriven。

1.拦截器执行的时机

拦截器执行的时机就是action创建完成之后在action调用的方法之前调用。

2.底层原理

1.aop思想

aop就是面向切面编程。如果我们需要扩展一个类的功能，一般来说我们会写一个父类，

2017-08-22

-JAVA

Struts2笔记(二)

1.结果页面

1.全局结果页面

当一些方法的返回值一样的时候并且需要跳转的页面也一样的时候就可以使用全局结果页面。

<package name="struts" extends="struts-default" namespace="/">
    <global-results>
        <result name="done">index.jsp</result>
    </global-results>
    <action name="hello" class="demo01.Hello">
        <result name="success">/index.jsp</result>
    </action>
</package>

注意他只是太某一个package中，而不是整个项目

2017-08-22

-JAVA

Struts2笔记(一)

1.创建Action

创建action需要继承ActionSupport类，然后就会有一些常量以及一些方法。
struts2的action默认执行的方法就是execute()方法

2017-08-21

-JAVA

Hibernate笔记(三)

1.对象导航查询

两个相关的对象

2.OID查询

用id查出对象

3.hql查询

Query对象

2017-08-21

-JAVA

Hibernate笔记(二)

1.一对多的关系映射

对于一的一方：

2017-08-21

-Java Web

Hibernate笔记(一)

1.导入jar包

jar包主要需要导入的有两个文件夹下面的jar包

required 必须要导入的核心包

jpa 实体规范的包

2.写一个实体类

实体类必须要有一个唯一的id值，对应于表中的主键。其他的就是字段值，字段值不一定和数据库的字段一样，而是可以不一样，然后在配置文件中进行映射。
然后生成对应的get与set方法。

3.写映射配置文件

一般位置就是放在该实体类的位置，名字后缀最好是hbm.xml,然后导入dtd的约束。这个约束是mapping的约束注意不要导错了。

<class name="类路径" table="表名">
  <id name="实体字段" column="表字段">
    <!-- 主键的生成策略，常用的就是native自增长，还有就是uuid使用128位的uuid算法产生uuid -->
    <generter>native</gengrter>
  </id>
  <property name="" column=""/>
  <property name="" column=""/>
  <property name="" column=""/>
</class>

4. 写Hibernate的核心配置文件

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!--DB base config-->
        <property name="connection.url"/>
        <property name="connection.driver_class"/>
        <property name="connection.username"/>
        <property name="connection.password"/>

         <!--DB schema will be updated if needed-->
        <property name="hbm2ddl.auto">update</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!--DB Mapping-->
        <mapping resource=""/>
    </session-factory>
</hibernate-configuration>

4.Hibernate代码

public class Main {
    private static final SessionFactory ourSessionFactory;
    //由于创建sessionFactory的时候他会去创建表，非常耗资源，所以一个项目之创建一个SessionFactory
    //所以我们写一个工具类，在静态代码快中，只被加载一次
    static {
        try {
            Configuration configuration = new Configuration();
            configuration.configure();
            ourSessionFactory = configuration.buildSessionFactory();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static Session getSession() throws HibernateException {
        return ourSessionFactory.openSession();
    }

    public static void main(final String[] args) throws Exception {
      //session是单例的，不可多线程公用，也就是一个session只能被一个线程使用。我们可以使用threadLocal来把session和本地线程绑定。
        final Session session = getSession();
        try {
            System.out.println("querying all the managed entities...");
            final Map metadataMap = session.getSessionFactory().getAllClassMetadata();
            for (Object key : metadataMap.keySet()) {
                final ClassMetadata classMetadata = (ClassMetadata) metadataMap.get(key);
                final String entityName = classMetadata.getEntityName();
                final Query query = session.createQuery("from " + entityName);
                for (Object o : query.list()) {
                    System.out.println("  " + o);
                }
            }
        } finally {
            session.close();
        }
    }
}

5.实体类编写规范

属性为私有的
必须有一个唯一的值一般都是id或者uid
属性一般都是使用包装类型，不要使用基本数据类型，就是防止出现null类型的。

6.CRUD操作

1.增加

首先需要一个对象，这个也就是实体类的对象，然后设置字段的值，最后只需要调用session.save(user)即可插入一条数据。

2.查询

根据id查询，直接使用session.get(User.class,id) 第一个参数就是类，第二个是id值。最后返回的不是数组或者list什么的，而是一个实体类的对象。

3.修改

首先就需要进行查询，然后修改实体的属性，最后再使用update方法保存即可。save方法也可以，但是如果记录不存在他就会添加。

4.删除

还是先查到该对象，然后在调用delete方法。

7.一级缓存

Hibernate的一级缓存默认是开启的，他的范围是在session开启导session关闭之间的，一级缓存的存放的对象只能就是持久太的数据。
一级缓存一个简单的例子就是，我们第一次查询一条数据的时候这条数据就被被放在内存中，而第二次再次查询此数据的时候他不会取数据库获取数据，而是直接从内存中取到这条数据。
Hibernate也是有耳机缓存的，但是现在基本不再使用，而是通过一些NoSQL数据库来完成，存放类似于SessionFactory对象之类的东西。

8.session和本地线程绑定

因为session是单例的不可以多个线程同时访问，我们可以使用threadLocal来绑定session和Thread，但是这样比较麻烦，我们Hibernate已经提供了session和thread绑定的方法。
首先需要配置核心配置文件
thread
然后SessionFactory.getCurrentSession()就是获得的与本地线程绑定的线程。线程结束以后session自动被销毁，不需要我们自己关闭session，否则会报错。

9.Hibernate三个查询对象

Query 执行hql语句，调用对应的方法获取结果

1 2	Query query=session.createQuery("hql"); //执行hql query.list(); //获取一个list集合

Criteria 无需执行hql，直接调用方法获取结果

1 2	Criteria criteria=session.createCriteria(User.class); //实体类的class criteria.list();

SQLQuery 调用底层sql

1 2	SQLQuery sql=session.createSQLQuery("sql");//执行sql sql.list() //每一条记录是一个数组

2017-08-21

-JAVA

jsp指令和EL表达式

1.page指令

1.pageEncoding

指定jsp的编码

2.contextType

设置响应头
这两个东西其实使用任意一个即可。

2017-08-21

-Java Web

JavaWeb基础二:JSP

1. JSP 标签

我们常用的 jsp 标签有两种，实际上有三种 jsp 标签。

<% %> 这种就是可以放 java 代码
<%= %> 这种就是输出语句，类似 PHP 中的简写语法
<%! %> 放各种生命代码，基本不用。

其实JSP最终还是一个Servlet，主要他的优点在于，可以在一个Servlet中直接写html代码，防止我们去写很多 out.print(“html代码”) ，或者说我们可以在html中写 java 脚本。但是并不是说我们使用了jsp 就不再使用Servlet，他们之间是有区别的，分工不一样。

jsp主要就用来显示表单，显示数据结果
Servlet就是用来处理数据，返回给jsp
2. JSP 原理
服务器启动后的第一次访问时，服务器会把这个文件转化为java文件，并且这个java文件是实现了servlet接口的一个类然后再把此java文件，转化成一个class文件，实例化对象，然后调用service方法。而在第二次访问的时候就是直接调用service方法。这也就是第一次惩戒。jsp被编译成的java放在了tomcat的work目录下面。
具体的看一下jsp编译出来的文件的时候就会发现里面是有六个private对象，还有两个分别就是request和response被tomcat传入。也就是有8个对象，还有一个exception没在这。所以这里就知道了jsp的九大内置对象。

3. JSP指令

1. page指令

1. pageEncoding

指定jsp的编码

2. contextType

设置响应头这两个东西其实使用任意一个即可。

3. errorPage

如果这个页面抛出异常以后重定向到哪一个页面。

4. IsErrorPage=true

标记这个页面可使用 expection 对象，其他页面不行。

5. session=”true”

当前页可使用 session 对象

2. 静态包含 include

他是静态包含和RequestDispatcher类似，但是就是包含的时期不一样。静态包含就是在jsp编译成java的时候形成的，也就是最终是两个文件合并成了一个class，最后形成一个class文件。
RequestDispatcher则是动态包含，他们在显示之前始终是两个java文件，两个class，在最后需要显示的时候才把内容整合发送给客户端。

3. 导入标签库 import

prefix制定标签库的前缀，uri就是标签库的位置。

4.九大内置对象

out jsp的输出流，向浏览器输出数据
page 当前的jsp对象，也就是在编译成大java中有page=this
config 对应的servletConfig对象
pageContext 代理其他的所有域对象，在标签之间传数据。
request
response
exception
session （HttpSession）
application （servletContext）

5.四大对象作用范围

ServletContext 一个应用
Session 一个会话
Request 一个请求
pageContext 一个jsp页面，一般用来jsp标签的数据传输

6.pageContext作用

代理其他的三大域对象
pageContext.setAttribute(“key”,”value”,pageContext.SESSION_SCOPE); 存放在session中代理了session
全域查找
pageContext.findAttribute(“key”) 在这四大域对象中依次查找
获取其他的jsp八大内置对象

7.JSP动作标签

<jsp:forward page=””/> 转发
<jsp:include page=””/> 包含
<jsp:param name=”” value=””/> 为其他的标签传递参数

8.EL表达式

EL表达式主要就是用来代替JSP中的 <%= %> 这个标签的，他可以简单的用于输出语句

输出四大域对象中的内容
${key} 这样就可以全域查找到四大域对象中的key变量如果key是一个对象的话，我们希望获取这个对象里面的某个get方法的返回值，我们只需要key.key1 key1就是getKey1()这个方法的返回值。
精确的四大域对象查找
${pageScope.key}
${requestScope.key}
${sessionScope.key}
${applicationScope.key}
其他7个内置对象

param
paramValue
header
headerValue
cookie
pageContext 他可以获取其他所有的10个对象，因为它里面有其他十个对象的get方法。

EL 函数库
导入对应的库，然后使用标签调用函数库

9.JSTL

JSTL是EL的扩展，因为EL只是进行输出而已，但是有一些判断，遍历等等，这些操作就是JSTL。他需要引入jstl.jar
他有四大库，但是常用的只有两个一个是core另外一个就是formate标签库
注意导入的时候uri是jsp/core 或者 jsp/formate

1.core标签库(c标签)

out 输出标签 value就是要输出的变量
set 设置某个变量的值 var变量名 value变量值
url url格式化的标签 value 自动添加上项目名里面如果加param标签那么就可以传递参数 name/value
remove 删除域变量 var变量名 scope域范围，不写的话删除全域的对象中的此值
if if语句 test 判断的条件 ${not empty key} 如果key不是空
forEach
- 计数方式 var循环变量 begin循环变量从几开始 end到几结束 step设置步长
- 用来遍历 items需要迭代的变量 var每一次迭代的变量
choose/when 多分支

<c:choose>
  <c:when test></c:when>
  <c:when test></c:when>
  <c:when test></c:when>
  <c:when test></c:when>
</c:choose>

2.formate标签库

formateDate value需要格式化的变量 pattern yyyy-MM-dd HH:mm:ss
formateNumber value变量 pattern 0.00 需要小数点两位四舍五入

2017-08-19

-Java

Java多线程JUC

1. volatile 关键字

多线程访问的时候，一个比较严重的问题就是内存不可见，其实在内存访问的时候每一个线程都有一个自己的缓冲区，每次在做修改的时候都是从主存取到数据，然后放到自己的缓冲区中，在做完修改之后放回主存。这样每一个线程之间的变量是不可见的。造成读到的数据可能始终就是错误的，因此有一个关键字可以使得这个共享变量称为透明的。就好像所有的操作就直接是在内存中操作一样，因为他一直不停的去同步主存的数据。

1.基本介绍

1.拦截器执行的时机

2.底层原理

1.aop思想

1.结果页面

1.全局结果页面

1.创建Action

1.对象导航查询

2.OID查询

3.hql查询

1.一对多的关系映射

1.导入jar包

2.写一个实体类

3.写映射配置文件

4. 写Hibernate的核心配置文件

4.Hibernate代码

5.实体类编写规范

6.CRUD操作

1.增加

2.查询

3.修改

4.删除

7.一级缓存

8.session和本地线程绑定

9.Hibernate三个查询对象

1.page指令

1.pageEncoding

2.contextType

1. JSP 标签

2. JSP 原理

3. JSP指令

1. page指令

1. pageEncoding

2. contextType

3. errorPage

4. IsErrorPage=true

5. session=”true”

2. 静态包含 include

3. 导入标签库 import

4.九大内置对象

5.四大对象作用范围

6.pageContext作用

7.JSP动作标签

8.EL表达式

9.JSTL

1.core标签库(c标签)

2.formate标签库

1. volatile 关键字