Java学习札记2013

 

Java学习札记2013

 

 

 

姓名：刘显安

 

 

 

2013年3月11日

 

 

第一个月：

20130311：

内存溢出的三种形式：

1. 堆溢出：

/** * @author LXA * 堆溢出 */ public class Heap {     public static void main(String[] args)     {         ArrayList list=new ArrayList();         while(true)         {             list.add(new Heap());         }     } }

报错：

java.lang.OutOfMemoryError: Java heap space

1. 栈溢出：

/** * @author LXA * 栈溢出 */ public class Stack {     public static void main(String[] args)     {         new Stack().test();     }     public void test()     {         test();     } }

报错：

java.lang.StackOverflowError

1. 方法区溢出

 

20130312：

集合

线程

数据库

20130313：

数据库连接池：

反射：

package C_20130313_反射; import java.lang.reflect.Method; class User {     private String name;     public User(){}     public User(String name)     {         this.name=name;     }     public void say()//无参的方法     {         System.out.println("大家好，我叫"+name+"！");     }     public void say(String str)//有参的方法     {         System.out.println("大家好，我叫"+name+"！"+str+"，我是有参的方法！");     } } /** * @author LXA * 反射最简单的例子 */ public class反射 {     public static void main(String[] args) throws Exception     {         Class c=Class.forName("C_20130313_反射.User");//通过反射找到对应的类         Method m1=c.getMethod("say");//找到名字叫做say、且无参的方法         Method m2=c.getMethod("say",String.class);//找到名字叫做say、且有一个String类型参数的方法         m1.invoke(c.newInstance());//注意newInstance()调用的是无参的构造方法！！！         m2.invoke(new User("刘显安"),"哈哈");//通过有参的构造方法实例化一个对象     } }

 

静态代理

动态代理：

文件IO：

Socket编程：

20130314:

模拟Tomcat：

20130318（Struts）

20130319（Hibernate）

缓存策略

保存策略

加载策略

单向关联

双向关联

20130320（Spring）

最近一直在搞正则表达式

20130322（周五，上课最后一天）:

23号开始做项目了。

今天碰到的奇葩事情：

public static void main(String[] args) throws Exception {     File file=new File("F:\\1.txt");     System.out.println(file.exists());     FileReader fr=new FileReader(new File("‪F:\\1.txt")); }

输出结果如下：

但是如果代码改为如下：

public static void main(String[] args) throws Exception {     File file=new File("F:\\1.txt");发生     System.out.println(file.exists());     FileReader fr=new FileReader(file); }

就不会有任何错误，真是奇葩！！！谁能解释一下不？

20130325：

敲代码第一天：

发现Eclipse一个很不好的地方：运行时不会自动给你保存，而MyEclipse会给你自动保存！

20130326:

今天改写jstl。

关于Java的值传递与引用传递：

其实这个问题很好理解：

Java参数，不管是原始类型还是引用类型，传递的都是副本，也就是把参数复制一份再传过去，但是：

如果参数类型是原始类型，那么直接把这个参数的值复制一份传过去，所以如果在函数中改变了副本的值，原始的值是不会改变的。

如果参数类型是引用类型，那么传过来的就是这个参数的地址的副本，如果在函数中没有改变这个副本的地址，而是改变了地址所指向的东西，那么在函数内的改变肯定会影响到传入的参数。但是如果在函数中改变了副本的地址（比如new一个，那么副本就指向了一个新的地址），此时在函数里面做的所有修改都针对是对那个新地址所指向的对象，所以原始的值不会改变。

多说无益，看下面最简单的例子：

class Student {     int age=20;//学生的初始年龄设置为20 } public class T {     public static void main(String[] args)     {         Student stu=new Student();         System.out.println("学生初始年龄："+stu.age);         update(stu); //将stu作为参数传过去         System.out.println("修改后的学生年龄："+stu.age);     }     public static void update(Student stu)     {         stu.age=21;     } }

输出结果：

学生初始年龄：20 修改后的学生年龄：21

如果将update方法改为如下：

public static void update(Student stu) {     stu=new Student();//此时stu指向的是一个新地址     stu.age=21; }

那么输出结果将变成：

学生初始年龄：20 修改后的学生年龄：20

 

注意：虽然上面说如果是引用类型会改变原始值，但是对于final的对象就不灵验了，比如String就是final的，因为final类是不可改变的，所以当改变了String的值时其实又new了一个String，自然原始值是不会跟着改变的（Integer等包装类都是final的）。

 

其实这就解释了为什么用String和StringBuffer做参数结果不一样。

Hibernate注解的使用：

注解和xml配置差不多，但能够少一半的文件，并且由于一般实体类的大部分属性都不需要配置什么，所以用配置文件会感觉有很大的冗余，这时注解就会大有用处！

1. 导包：

   在MyEclipse9中，一般导入以下2个库：核心库和注解库

1. 最简单的实体类（注意注解使用的都是 javax.persistence包下面的，别导错包了！）：

package entity;   import javax.persistence.Basic; import javax.persistence.Entity; import javax.persistence.Id;   @Entity public class Emp {     @Id     private int emp_id;//员工ID     @Basic     private String emp_name;//员工姓名 //省略get和set }

1. hibernate.cfg.xml文件：

本人是在项目根目录下新建一个config"源文件夹"，然后将所有配置文件都放在这个文件夹下（注意普通文件夹必须先构建路径使之成为源文件夹），然后使用默认配置文件名称hibernate默认就能够找到它。

注意：下面2行黄色标注部分先不用看！！！

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory>     <property name="show_sql">true</property>     <property name="format_sql">true</property>     <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>     <property name="connection.url"> jdbc:oracle:thin:@localhost:1521:xe</property>     <property name="connection.username">lxa</property>     <property name="connection.password">123</property>     <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>     <property name="hbm2ddl.auto">create</property>     <mapping class="entity.Emp"/>     <mapping resource="entity/Emp.hbm.xml"/> </session-factory> </hibernate-configuration>

 

1. Hibernate工具类的改写(部分代码)

public class HiberUtil {     private static SessionFactory sessionFactory;//全局的会话工厂     static     {         sessionFactory=new AnnotationConfiguration()             .configure()             .addAnnotatedClass(Dept.class) //有多少个实体类就add多少次             .addAnnotatedClass(Emp.class)             .buildSessionFactory();     }     /**      * 获取会话      */     public static Session getSession()     {         return sessionFactory.openSession();     } }

对于已经注解的实体类，必须还要注册，注册有2种方法：

1、也就是最上面配置文件里面的写法（也就是说除了在实体类的上面加一个@Entity之外，还要在配置文件里map一下）：

<mapping class="entity.Emp"/>

2、如果不喜欢在配置文件里写map，还可以在代码里注册，其实上面已经给出代码了，就是HiberUtil.java中的addAnnotatedClass()

补充：

hbm映射文件和注解可以混用。

 

可以发现，如果一个系统里面的实体类很多，那么一个个注册就很麻烦了，为此，本人写了一个简单的工具类来解决这个问题（其实就是类似Spring的包扫描，Spring的注解类之所以不需要注册，是因为它可以在配置文件里指定要扫描的包，不知道为什么hibernate不做这样一个功能！）

使用方法很简单：

static {     //以下是Hibernate3注册的方法     AnnotationConfiguration conf =new AnnotationConfiguration().configure();     PackageHelper.addPackage(conf, "entity");//指定要扫描的包名叫做entity     sessionFactory = conf.buildSessionFactory(); }

PackageHelper.java：

/** * @author LXA * 获取某个包下面所有类的工具类 * 2013/03/26 */ public class PackageHelper {     /**      * 为Hibernate注解配置对象添加注解类      * @param conf 配置对象      * @param packageName 要扫描的包名      */     public static void addPackage(AnnotationConfiguration conf,String packageName)     {         Set<Class<?>> cs=findClass(packageName);         for(Class<?> c:cs)             conf.addAnnotatedClass(c);         System.out.println("注册所有实体类完毕！");     }     /**      * 找到某一个包下面所有的类      * @param packageName      * @return      */     public static Set<Class<?>> findClass(String packageName)     {         Set<Class<?>> cs=new LinkedHashSet<Class<?>>();         try         {             //获取包名对应的真实物理地址             URL url = Thread.currentThread().getContextClassLoader().getResource(packageName.replace('.', '/'));             String packagePath = URLDecoder.decode(url.getFile(), "utf-8");//中文路径会存在乱码问题             findClass(packageName, packagePath,cs);         }         catch (UnsupportedEncodingException e)         {             e.printStackTrace();         }         return cs;     }       /**      * 递归的一个私有方法，供findClass(String packageName)调用      * @param packageName      * @param packagePath      * @param cs      */     private static void findClass(String packageName, String packagePath,Set<Class<?>> cs)     {         File dir = new File(packagePath);// 获取此包的目录建立一个File         if (!dir.exists() || !dir.isDirectory())// 如果不存在或者也不是目录就直接返回             return;         File[] dirfiles = dir.listFiles();// 如果存在就获取包下的所有文件包括目录         for (File file : dirfiles)// 循环所有文件         {             if (file.isDirectory())// 如果是目录则继续扫描                 findClass(packageName + "." + file.getName(),file.getAbsolutePath(),cs);             else             {                 if (file.getName().endsWith(".class"))// 如果是java类文件去掉后面的.class 只留下类名                 {                     String className = file.getName().replaceAll(".class$", "");                     try                     {                         // 这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净                         // Class c=Class.forName(packageName + '.' + className);                         Class c = Thread.currentThread().getContextClassLoader()                             .loadClass(packageName + '.' + className);                         cs.add(c);                     }                     catch (ClassNotFoundException e)                     {                         e.printStackTrace();                     }                 }             }         }     } }

20130327：

三种常见数据库连接方式：

MySQL： jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/test jdbc.username=root jdbc.password=admin   Oracle： jdbc.driver=oracle.jdbc.driver.OracleDriver jdbc.url=jdbc:oracle:thin:@127.0.0.1:1521:orcl jdbc.username=scott jdbc.password=tiger   MS SQL Server： jdbc.driver= com.microsoft.jdbc.sqlserver.SQLServerDriver jdbc.url= jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mssql jdbc.username=sa jdbc.password=sa

Hibernate注解进阶：

• Hibernate的注解本着尽量采用默认设置的原则来减少注解的代码，具体体现请往下看。
• 实体bean中所有的非static的属性都可以被持久化, 除非你将其注解为@Transient（相当于不让这个属性映射到数据库中去）
• 所有没有定义注解的属性等价于在其上面添加了@Basic注解. 通过 @Basic注解可以声明属性的获取策略(fetch strategy)：
• 注解可以写在属性上，也可以写在方法上，但应尽量避免2种方法混用：要么都写在属性上，要么都写在get方法上。
• 你可以在实体bean中使用@Version注解,通过这种方式可添加对乐观锁定的支持,version列可以是numeric类型(推荐方式)也可以是timestamp类型.

如果想对一个列的属性进行具体设置：

@Column(name="dept_name_222",length=100,nullable=false) private String dept_name;//部门名称

无注解之属性的默认值

如果某属性没有注解,该属性将遵守下面的规则:

如果属性为 单一类型,则映射为 @Basic 否则,如果属性对应的类型定义了@Embeddable注解,则映射为@Embedded 否则,如果属性对应的类型实现了Serializable, 则属性被映射为@Basic并在一个列中保存该对象的serialized版本 否则,如果该属性的类型为java.sql.Clob 或 java.sql.Blob,则作为@Lob并映射到适当的LobType.

 

主键生成策略：

使用@Id注解可以将实体bean中的某个属性定义为标识符(identifier). 该属性的值可以通过应用自身进行设置, 也可以通过Hiberante生成(推荐). 使用 @GeneratedValue注解可以定义该标识符的生成策略:

 

AUTO	自动，推荐使用，可以是identity column类型,或者sequence类型或者table类型,取决于不同的底层数据库.
TABLE	使用表保存id值
IDENTITY	identity column，数据库自带的主键自增策略，如SQL Server和MySQL
SEQUENCE	序列，适用于Oracle

主键一般定义如下：

@Id @GeneratedValue(strategy=GenerationType.AUTO) private int emp_id;//员工ID

使用注解实现关联映射：

多对一：

员工表：

@Entity public class Emp {     @Id @GeneratedValue(strategy=GenerationType.AUTO)     private int emp_id;//员工ID     private String emp_name;//员工姓名     @ManyToOne     private Dept deptaa;//对应的部门     public Emp(){}     public Emp(String emp_name)     {         this.emp_name=emp_name;     } //省略get和set }

部门表：

@Entity public class Dept {     @Id @GeneratedValue(strategy=GenerationType.AUTO)     private int dept_id;//部门ID     private String dept_name;//部门名称     @Transient //这个表示emps只是普通字段，不会关联到数据库，相当于"注释"     private Set<Emp> emps;//员工集合     public Dept(){}     public Dept(String dept_name)     {         this.dept_name=dept_name;     } //省略get和set }

生成的表结构如下：

Dept:

Emp:

生成的外键：

如果想自己指定emp中外键的列名：

@ManyToOne @JoinColumn(name="fsdfs") private Dept deptaa;//对应的部门

一对多：

Dept.java:

@Entity public class Dept {     @Id @GeneratedValue(strategy=GenerationType.AUTO)     private int dept_id;//部门ID     private String dept_name;//部门名称     @OneToMany     private Set<Emp> emps;//员工集合     public Dept(){}     public Dept(String dept_name)     {         this.dept_name=dept_name;     } //省略get和set }

Emp.java(部分代码):

@Transient //相当于把deptaa给注释掉     private Dept deptaa;//对应的部门

此时会生成3张表：

另外会生成一个中间的"联结表"，表名默认是：主表表名+下划线+从表表名，所以这里是：dept_emp

关于这个中间连接表，Hibernate官方解释如下：

通过在被拥有的实体端(owned entity)增加一个外键列来实现一对多单向关联是很少见的,也是不推荐的. 我们强烈建议通过一个联接表(join table)来实现这种关联. 通过联接表处理单向一对多关联是首选方式.这种关联通过@JoinTable注解来进行描述（这个JoinTable不重要）。

当然，如果你不喜欢多一个中间表，可以这样(别的地方都不用改，只需改下面)：

@OneToMany @JoinColumn(name="empp_id")//指定从表中外键的名字，此时不会生成中间表 private Set<Emp> emps;//员工集合

20130328

HTTP错误代码表：

所有 HTTP 状态代码及其定义。 
　代码  指示  
2xx  成功  
200  正常；请求已完成。  
201  正常；紧接 POST 命令。  
202  正常；已接受用于处理，但处理尚未完成。  
203  正常；部分信息 — 返回的信息只是一部分。  
204  正常；无响应 — 已接收请求，但不存在要回送的信息。  
3xx  重定向  
301  已移动 — 请求的数据具有新的位置且更改是永久的。  
302  已找到 — 请求的数据临时具有不同 URI。  
303  请参阅其它 — 可在另一 URI 下找到对请求的响应，且应使用 GET 方法检索此响应。  
304  未修改 — 未按预期修改文档。  
305  使用代理 — 必须通过位置字段中提供的代理来访问请求的资源。  
306  未使用 — 不再使用；保留此代码以便将来使用。  
4xx  客户机中出现的错误  
400  错误请求 — 请求中有语法问题，或不能满足请求。  
401  未授权 — 未授权客户机访问数据。  
402  需要付款 — 表示计费系统已有效。  
403  禁止 — 即使有授权也不需要访问。  
404  找不到 — 服务器找不到给定的资源；文档不存在。  
407  代理认证请求 — 客户机首先必须使用代理认证自身。  
415  介质类型不受支持 — 服务器拒绝服务请求，因为不支持请求实体的格式。  
5xx  服务器中出现的错误  
500  内部错误 — 因为意外情况，服务器不能完成请求。  
501  未执行 — 服务器不支持请求的工具。  
502  错误网关 — 服务器接收到来自上游服务器的无效响应。  
503  无法获得服务 — 由于临时过载或维护，服务器无法处理请求。
-----------------------------------------------------------------------------------------------------------------------
HTTP 400 - 请求无效 
HTTP 401.1 - 未授权：登录失败 
HTTP 401.2 - 未授权：服务器配置问题导致登录失败 
HTTP 401.3 - ACL 禁止访问资源 
HTTP 401.4 - 未授权：授权被筛选器拒绝 
HTTP 401.5 - 未授权：ISAPI 或 CGI 授权失败  
HTTP 403 - 禁止访问 
HTTP 403 - 对 Internet 服务管理器 (HTML) 的访问仅限于 Localhost 
HTTP 403.1 禁止访问：禁止可执行访问 
HTTP 403.2 - 禁止访问：禁止读访问 
HTTP 403.3 - 禁止访问：禁止写访问 
HTTP 403.4 - 禁止访问：要求 SSL 
HTTP 403.5 - 禁止访问：要求 SSL 128 
HTTP 403.6 - 禁止访问：IP 地址被拒绝 
HTTP 403.7 - 禁止访问：要求客户证书 
HTTP 403.8 - 禁止访问：禁止站点访问 
HTTP 403.9 - 禁止访问：连接的用户过多 
HTTP 403.10 - 禁止访问：配置无效 
HTTP 403.11 - 禁止访问：密码更改 
HTTP 403.12 - 禁止访问：映射器拒绝访问 
HTTP 403.13 - 禁止访问：客户证书已被吊销 
HTTP 403.15 - 禁止访问：客户访问许可过多 
HTTP 403.16 - 禁止访问：客户证书不可信或者无效 
HTTP 403.17 - 禁止访问：客户证书已经到期或者尚未生效 
HTTP 404.1 - 无法找到 Web 站点 
HTTP 404 - 无法找到文件 
HTTP 405 - 资源被禁止 
HTTP 406 - 无法接受 
HTTP 407 - 要求代理身份验证 
HTTP 410 - 永远不可用 
HTTP 412 - 先决条件失败 
HTTP 414 - 请求 - URI 太长 
HTTP 500 - 内部服务器错误 
HTTP 500.100 - 内部服务器错误 - ASP 错误 
HTTP 500-11 服务器关闭 
HTTP 500-12 应用程序重新启动 
HTTP 500-13 - 服务器太忙 
HTTP 500-14 - 应用程序无效 
HTTP 500-15 - 不允许请求 global.asa 
Error 501 - 未实现 
HTTP 502 - 网关错误 

20130329：

今天把整个项目改用SSM框架来写，晚上验收。

MyBatis的使用：

MyBatis原名ibatis，是2010年开始改为此名的，据网上介绍说，它相对Hibernate而言优点主要是：半封装、轻量级（不整合Spring的话只有一个jar包，才685kb），SQL语句还是我们自己写，但从数据中取出来的数据可以直接封装成对象，相比Hibernate为了方便而"牺牲性能"，MyBatis二者都考虑了。

Demo项目结构：

基本步骤：

1. 新建一个Java项目
2. 导入mybatis-3.2.1.jar和MySQL的驱动包
3. 手工到数据库中建一个名为student的表，字段s_id,s_name，注意s_id设为自增：

 

1. 实体类：entity.Student.java

public class Student {     private int s_id;     private String s_name;     public Student(){} //省略get和set }

5、dao.StudentDao.java：

/** * @author LXA * 学生类Dao，注意必须是接口 */ public interface StudentDao {     public void insert(Student student);//增     public void delete(int s_id);//删     public void update(Student student);//改     public Student getOne(int s_id);//查单个     public List<Student> getList();//查集合 }

1. 映射文件，SQL语句都写在这里面：

注意里面id都和上面的dao方法对应！

dao.StudentDaoMap.xml：

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="dao.StudentDao">     <insert id="insert" parameterType="entity.Student">         insert into student(s_name) values(#{s_name})     </insert>     <delete id="delete" parameterType="int">         delete from student where s_id=#{s_id} </delete> <update id="update" parameterType="entity.Student">     update student set s_name=#{s_name} where s_id=#{s_id} </update> <select id="getOne" parameterType="int" resultType="entity.Student">     select * from student where s_id=#{s_id} </select> <select id="getList" resultType="entity.Student">     select * from student </select> </mapper>

1. MyBatis配置文件：mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration>     <environments default="development">         <environment id="development">             <transactionManager type="JDBC" />             <dataSource type="POOLED">                 <property name="driver" value="com.mysql.jdbc.Driver" />                 <property name="url" value="jdbc:mysql://localhost:3306/test" />                 <property name="username" value="root" />                 <property name="password" value="1" />             </dataSource>         </environment>     </environments>     <mappers>         <mapper resource="dao/StudentDaoMap.xml" />     </mappers> </configuration>

1. 测试：Test.java

public static void main(String[] args) throws IOException {     String resource = "mybatis-config.xml"; Reader reader = Resources.getResourceAsReader(resource); SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader); //一般一个项目只需要一个factory SqlSession session=factory.openSession();//和Hibernate一样，一个session对应一个连接 StudentDao dao=session.getMapper(StudentDao.class); //这个dao建议和session一样，到用的时候再获取，也就是说其生命周期比较短   dao.insert(new Student("王老板"));//增，主键自增 dao.insert(new Student("刘显安")); dao.insert(new Student("小萃")); List<Student> list=dao.getList();//查 for(Student student:list)     System.out.println(student.getS_id()+","+student.getS_name());   dao.update(new Student(22, "小小萃"));//改 Student student=dao.getOne(22);//查 System.out.println("修改之后："+student.getS_id()+","+student.getS_name()); dao.delete(22);//删   session.commit();//提交 session.close();//关闭session }

关于MyBatis多个参数的问题：

先看一下上面的例子：

<update id="update" parameterType="entity.Student">     update student set s_name=#{s_name} where s_id=#{s_id} </update>

修改时传入一个Student对象，在SQL中引用对象属性时我们直接用：

#{属性}即可。

但是如果传入多个参数呢？

网上有的用Map方式，有的用Bean方式，最简单的还是下面这样：

假设某方法如下(当然这个例子不是很恰当)：

public void update(Student student,int abc);//改

因为它有2个参数，所以这样改写：

public void update(@Param("s")Student student,@Param("abc")int abc);//改

然后映射文件如下：

<update id="update" parameterType="entity.Student"> update student set s_name=#{s.s_name} where s_id=#{abc} </update>

意思是：因为有多个参数，所以现在要引用某个参数的属性，需指定其名称以免混淆（这里是s），而名称就是在方法里面用@Param指定的。

MyBatis的if和sql引用：

无需多言，看看就能明白：

/** * 查询总的记录条数 * @return */ public int getCount(@Param("vo")ShiftSheetInfoVO vo);

映射文件：

<select id="getCount" resultType="int"> select count(*) from shift_sheet_info where 1=1 <include refid="queryLike"/> </select> <sql id="queryLike"> <if test="vo.sheet_num!=null and vo.sheet_num !=''">     and sheet_num like #{vo.sheet_num} </if> <if test="vo.sheet_name!=null and vo.sheet_name!=''">     and sheet_name like #{vo.sheet_name} </if> </sql>

MyBatis的模糊查询和in语法：

MyBatis会自动在所有的形如#{s_id}外面加上个单引号，所以模糊查询用不了：

一般模糊查询语句如下：

select * from student where s_name like '%萃%'

（MySQL中单引号和双引号都可用）

这样写肯定是错误的：

select * from student where s_name like %'萃'%

所以在MyBatis中貌似模糊查询用不了，因为：

不管是#{%s_name%}还是%#{s_name}%都不正确！

 

下面分析一下in语法行不通的问题：

当主键为int类型时：

select * from student where s_id in (1,2,3,5,7)

当主键为varchar类型时：

select * from student where s_id in ('安','萃','涛哥')

因为MyBatis会自动在传入的字符串2边加上单引号，所以如果我们传入的字符串是（即头和尾不要单引号，中间有单引号和逗号）：

安','萃','涛哥

那么理论上是可以查询的到数据的，但是坑爹的是，MyBatis自动把我们自己的单引号全部给转义了：

另外说明一点，如果想看到执行后的SQL语句，可以故意把它附近的语句写错，比如上面的我故意把in写成ini，所以肯定会报错，在页面上就可以看到真正的SQL语句了。

几点总结：

1. MyBatis的dao让spring管理的方法：所有dao都继承自一个BaseDao，然后在Spring的配置文件中指定BaseDao这一个bean即可，其它继承的Dao都会自动创建Bean。
2. JSTL的一个小问题：<c:forEach>里面是可以嵌套<c:if>的，只是在你刚开始写的时候IDE可能会提示错误，但是等你写完了就不会再提示了。

如：

<c:forEach items="${shift_factory }" var="sf">         <option value="${sf.codeCoding }"<c:if test="${sf.codeCoding== vo.out_factory}">selected</c:if>>${sf.codeName }</option> </c:forEach>

 

1. MySQL中时间类型一般用java.sql.TimeStamp
2. MySQL和SQL Server一样有数据库自带的自增属性，不像Oracle还要单独搞一个Sequence，麻烦！
3. MySQL的分页也比Oracle简单多了，一个limit 20,10即表示每页10条记录、查询第3页，前面一个是索引（从0开始），后面是查询的条数
4. 浏览器的兼容性还是一个很大的问题！
5. Hibernate真的是一个重量级框架！很重很重！一个项目中加了Hibernate后启动速度大打折扣！
6. 注解就是比配置好用，但像MyBatis把原本放在Java代码中的SQL语句放到Xml配置文件中，如果再反过来把SQL语句改用注解来写在Java类中，那真不知道对这说什么好了！个人觉得实在没必要！

 

 

 

 

SSM整合步骤：

整个demo程序结构如下，先在数据库手工建一个student的表再往下看：

1. 导入好多好多包，struts的、mybatis的2个，spring一大堆，自己稍微整理了下：

1. 和配置SSH类似，web.xml的几个配置：

<!-- Struts2过滤器 -->     <filter>         <filter-name>struts2</filter-name>         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>     </filter>     <!-- Struts2过滤器映射 -->     <filter-mapping>         <filter-name>struts2</filter-name>         <url-pattern>/*</url-pattern>     </filter-mapping>        <!-- Spring编码过滤器 -->     <filter>         <filter-name>encodingFilter</filter-name>         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>         <init-param>             <param-name>encoding</param-name>             <param-value>UTF-8</param-value>         </init-param>     </filter>     <!-- Spring编码过滤器映射 -->     <filter-mapping>         <filter-name>encodingFilter</filter-name>         <url-pattern>/*</url-pattern>     </filter-mapping>       <!-- Spring 配置文件的本地路径 -->     <context-param>         <param-name>contextConfigLocation</param-name>         <param-value>classpath:applicationContext.xml</param-value>     </context-param>          <!-- Spring配置信息加载监听器 Context Listener -->     <listener>         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>     </listener>     <!-- Spring Web请求监听器 -->     <listener>         <listener-class>             org.springframework.web.context.request.RequestContextListener</listener-class>     </listener>

1. struts.xml文件，这个太简单，省略了。
2. applicationContext.xml：

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"     xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"     xmlns:aop="http://www.springframework.org/schema/aop"     xsi:schemaLocation="http://www.springframework.org/schema/beans     http://www.springframework.org/schema/beans/spring-beans-3.1.xsd     http://www.springframework.org/schema/aop     http://www.springframework.org/schema/aop/spring-aop-3.1.xsd     http://www.springframework.org/schema/tx     http://www.springframework.org/schema/tx/spring-tx-3.1.xsd     http://www.springframework.org/schema/context     http://www.springframework.org/schema/context/spring-context-3.1.xsd">          <context:component-scan base-package="action,dao,biz,util,aop"/>     <!-- 设置Aop -->     <aop:aspectj-autoproxy proxy-target-class="true"/>     <!-- 数据源 -->     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"         destroy-method="close">                 <property name="driverClass" value="com.mysql.jdbc.Driver"/>      <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>      <property name="user" value="root"/>      <property name="password" value="1"/>     </bean>       <!-- SessionFactory -->     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">         <property name="dataSource" ref="dataSource" />         <!-- 指定Map映射文件的路径 -->         <property name="mapperLocations" value="classpath:dao/*.xml" />     </bean>     <!-- 注册BaseDao -->         <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">         <property name="basePackage" value="dao"/>         <property name="markerInterface" value="dao.BaseDao"/>     </bean> </beans>

 

1. 实体类Student.java，字段就是s_id和s_name2个，代码就略了。
2. 在dao包下建一个BaseDao.java：

package dao; /** * @author LXA * 最顶头的dao，所有dao都继承这个接口，目的是为了避免每个dao都在spring中注册 */ public interface BaseDao {   }

1. 再在dao包下新建一个StudentDao.java，注意继承自BaseDao.java（ 注意dao不能使用注解）：

/** * @author LXA * 学生类DAO，继承自BaseDao，注意是一个接口 */ public interface StudentDao extends BaseDao {     public void insert(Student student);//增     public void delete(int s_id);//删     public void update(Student student);//改     public Student getOne(int s_id);//查单个     public List<Student> getList();//查集合 }

1. 映射文件见： MyBatis的使用部分。
2. 业务层：StudentBiz.java：

@Service public class StudentBiz {     @Resource     private StudentDao dao;     public Student getOne(int s_id)     {         return dao.getOne(s_id);     } }

1. Action层：StudentAction.java：

@Controller public class StudentAction {     @Resource     private StudentBiz biz;     public String login()     {         Student student=biz.getOne(18);         System.out.println(student.getS_name());         return "ok";     } }

10、使用浏览器访问指定页面即可。

20130330：

基于MySQL的MyBatis分页：

select * from student limit 20,10;

以上语句表示每页10条，查询第3页。第一个20表示起始数据的索引（0表示第1条），后面的10表示查询10条记录。

MyBatis中如下使用：

StudentDao.java部分代码如下：

/**      * 获取学生信息列表      * @param stu 封装模糊查询的对象      * @param start 起始记录索引      * @param pageSize 每一页的大小      * @return      */     public List<Student> getList(@Param("s")Student stu, @Param("start")int start,@Param("pageSize")int pageSize);

映射文件：

<select id="getList" resultType="entity.Student"> select * from student where 1=1 <if test="s.s_name!=null and s.s_name !=''">     and s_name like #{s.s_name} </if> limit #{start},#{pageSize} </select>

显然这样不方便，因为每次调用还要自己计算起始索引，所以还应当在业务层进行二次封装：

StudentBiz.java部分代码：

/** * 获取学生信息列表 * @param vo 封装模糊查询的对象 * @param pageNo 页数 */ public List<Student> getList(Student s,int page,int pageSize) {     return dao.getList(s,(page-1)*pageSize,pageSize); }

 

JS中的EL表达式：

JavaScript中注释过的EL表达式仍然会被编译！（只能说这是EL表达式的一个天大的Bug），比如你写一个错误的EL表达式然后给它注释掉，访问那个页面还是会报错的。

 

关于Struts执行的流程：

20130331:

Eclipse一个不好的地方：

运行前不会自动保存没有保存的文件！

启动Eclipse时提示工作空间选择：

20130412（实习真正第一天）:

关于Struts2与自定义过滤器冲突的问题：

自定义了一个过滤器，内容如下：

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,         ServletException {     System.out.println("进入自定义过滤器");     chain.doFilter(request, response); }

如果自定义的过滤器映射放在struts2的前面，不论是拦截具体的后缀（如*.aaa）还是为/*，2个过滤器都能正常进入：

<filter>         <filter-name>test1</filter-name><!-- 自定义过滤器 -->         <filter-class>filter.StrutsFilter</filter-class>     </filter>     <filter-mapping>         <filter-name>test1</filter-name>         <url-pattern>/*</url-pattern>     </filter-mapping>          <filter> <filter-name>struts2</filter-name> <filter-class>         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter     </filter-class> </filter> <filter-mapping> <filter-name>struts2</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>

如果自定义过滤器放在了struts2的后面的话：

1. 如果自定义拦截的时/*，访问struts符合的后缀URL时（如.do，.action等）之进入struts过滤器，否则进入自定义的过滤器。
2. 如果拦截的是具体的，如*.bbb，那么只有访问的url后缀是bbb时才进入自定义。

 

总结：一句话，Struts很霸道，如果Struts过滤器放在了前面，那么一旦Struts把URL当成一个action，那么就不会进入自定义过滤器，如果自定义放在了前面，那么好办，一切正常OK！