利用反射机制完成所有hibernate的模糊、非模糊查询。可以按条件查询

有的时候我们会遇到这样的情况，比如图书馆有很多本书，这时候我们要按照书名查询，按照类别查询，按照作者查询，或者按照ISBN查询，并且有可能一次按照多个条件查询，这时候通常会需要如下的hql或者sql语句。

①　from Book b

where b.bookName=”红楼梦“ and b.bookAuthor=”施耐庵” ……

②　Select * from tb_book b where

b.bookName=”红楼梦“ and b.bookAuthor=”施耐庵” ……

并且在写servlet或者使用struts写action的时候需要针对不同的查询调用不同的DAO层，因此往往servlet或者dao需要写多个类似处理代码，他们几乎相同。

其实针对查询这些信息的时候我们完全可以利用反射机制来自动生成一条hql或者sql语句执行，不需要每次都写出新的语句，这样既不利于维护，也不利于开发。

我的设想就是，不管是否使用ORM框架，都需要有实体类对应数据库的表，而这些实体类的属性就对应了表的字段。

我们如果能利用一个实体类来进行针对自身不为null的属性生成hql或者sql语句，那么就可以利用一个查询的dao完成所有类型的查询了。

下面给出我写的hqlModel，这个类是一个用来生成查询语句的。

此类的中心思想就是自动生成查询语句，只要给定一个Object类型，就可以“自动”根据类的属性调用getter方法来获取值。如果值不为空，就按照该值来进行条件查询，如果没有任何属性被赋值，那么他将认为要生成form Book 这样的查询语句。

这样不管是查询所有数据，查询指定数据，多条件查询指定数据，都可以用同一个方法来执行。

至于模糊或者非模糊，只要给定一个boolean，然后判断就可以了。这样用setter作为其是否开启模糊查询的开关。


package com.leaves.daoUtil;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 此类用来创建hql查询语句，能自动生成如下格式hql语句。<br>
 * from BookInfo where bookNameId='null' and bookName='《三国演义》' and
 * bookAuthor='施耐庵' ;<br>
 * 使用getHql()方法来创建hql语句，此方法调用会抛出异常。<br>
 * 此类需要你为其提供一个带有get和set方法的bean，类会根据其get的方法获得其值，如果get属性不为null则添加where条件。<br>
 * 如果没有设置任何方法，则默认生成from BookInfo形式HQL语句。
 * 
 * @version 1.0.0.0
 * @author leaves叶知泉，<a href="http://www.c5ms.com">官方网站www.c5ms.com</a>
 * 
 */
public class HqlModel {

	private Object object;

	/**
	 * 是否开启模糊查询
	 */
	private boolean likeSel;

	public boolean isLikeSel() {
		return likeSel;
	}

	/**
	 * 设置属性是否开启模糊查询
	 * 
	 * @param likeSel
	 */
	public void setLikeSel(boolean likeSel) {
		this.likeSel = likeSel;
	}

	public Object getObject() {
		return object;
	}

	public void setObject(Object object) {
		this.object = object;
	}

	/**
	 * 允许不带参数实例化
	 */
	private HqlModel() {
	}

	/**
	 * 使用指定的对象来获取一个HqlModel实例
	 * 
	 * @param object
	 *            实例化时所需要的DTO对象
	 */
	public static HqlModel newInstanceByObj(Object object) {
		HqlModel hqlModel = new HqlModel();
		hqlModel.setObject(object);
		return hqlModel;
	}

	/**
	 * 用来进行创建hql语句的方法， 此方法可能抛出异常
	 * 
	 * @return 根据传入对象的get方法构建的hql语句
	 */
	public String getHql() throws Exception {
		// 预准备好的hql语句。
		StringBuffer sbf = new StringBuffer("from Object where ");
		// 得道给定实例的类型。
		Class<?> theClass = this.getObject().getClass();
		// 使用类名替换Object字符串。
		sbf.replace(5, 11, theClass.getSimpleName());
		// 活的该类所有属性。
		Field[] fields = object.getClass().getDeclaredFields();

		// 遍历所有属性
		for (Field field : fields) {
			PropertyDescriptor pd = new PropertyDescriptor(field.getName(),
					theClass);
			// 获得所有属性的读取方法
			Method getMethod = pd.getReadMethod();
			// 执行读取方法，获得属性值
			Object objTemp = getMethod.invoke(object);
			// 如果属性值为null，就略过
			if (objTemp == null) {
				continue;
			}
			// 如果不为空。
			// 判断是否开启模糊查询，添加查询条件,并且加上%%符号。
			if (isLikeSel()) {
				sbf.append(field.getName() + " like '%" + objTemp + "%'");
				sbf.append(" and ");
			}//同理添加查询条件，不添加%%符号。
			else {
				sbf.append(field.getName() + "='" + objTemp + "'");
				sbf.append(" and ");
			}
		}
		//最后一个属性设置完成之后取出残余的and和尾部的空格。
		if (sbf.toString().endsWith("and ")) {
			sbf.delete(sbf.length() - "and".length() - 1, sbf.length());
		}
		//如果没有设置任何属性，则取出尾部的where字符串和后面的空格。
		if (sbf.toString().endsWith("where ")) {
			sbf.delete(sbf.length() - "where".length() - 1, sbf.length());
		}
		//返回生成好的语句。
		return sbf.toString();
	}

}





目前属于1.0版本，还不支持sql语句生成，其实都是一个道理，只要在类中修改 StringBuffer sbf = new StringBuffer(“from Object where ”);这一句就能完成。

希望朋友们修改出更好的生成器之后能跟小弟一起分享，多多指教。

此类不足之处：

·没有sql、hql切换的开关

·理论上还可以生成update和save这样的语句，只是小弟还没有想到设计。

使用注解、反射和正则表达式完成表单验证
一、需求
二、Person类
三、Verify注解
四、TestWord测试类
五、输出结果

一、需求
完成表单验证功能，验证一个用户名的字段。字段上定义注解，有3个参数，分别为minLength、maxLength、keyWord.需要满足一下条件：

a). 用户名长度是否>=minLength

b). 用户名长度是否<=maxLength

c). 用户名中是否包含keyWord关键字

d). 大写字母、小写字母、数字必须选至少2种类型。
二、Person类
public class Person {
    @Verify(minLength = 6,maxLength = 15,keyWord = "abc")
    private String name ;//定义属性 用户名
}

三、Verify注解
import java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Verify {
   int minLength();
   int maxLength();
   String keyWord();
}

四、TestWord测试类
import java.lang.reflect.Field;
import java.util.Scanner;

public class TestWord {
    public static void main(String[] args) throws NoSuchFieldException {
        Person word = new Person();
        Class<Person> wordClass = Person.class;
        Field nField = wordClass.getDeclaredField("name");
        Verify myVerify = nField.getDeclaredAnnotation(Verify.class);

        String keyWord = myVerify.keyWord();
        int maxL= myVerify.maxLength();
        int minL = myVerify.minLength();

        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个字段：（大写字母、小写字母、数字必须选至少2种类型）");
         String getname=sc.next();
         String a =getname;
         int b=  a.length();
// a). 用户名长度是否>=minLength  b). 用户名长度是否<=maxLength
        if (b>=minL&&b<=maxL){
        }else {
            System.out.println("该字段的长度不在范围内");
            return;
        }
//  c). 用户名中是否包含keyWord关键字
      /*  if (a.matches(".*"+keyWord+".*")){
            System.out.println("t");
        }*/
        if(!a.contains(keyWord)){
            System.out.println("用户名中不包含keyWord关键字");
            return;
        }

//  d). 大写字母、小写字母、数字必须选至少2种类型。
        int count=0;
        if(a.matches(".*[0-9].*")){
            count++;
        }
        if(a.matches(".*[a-z].*")){
            count++;
        }
        if(a.matches(".*[A-Z].*")) {
            count++;
        }
        if (count>=2){
            System.out.println("用户名注册成功！");
        }
    }
}


五、输出结果

一、简介
  Lambert的光照模型是一个很经典的漫反射模型，光强与入射光的方向和反射点处表面法向夹角的余弦成正比。简单解释就是一个点的反射光强是和该点的法线向量和入射光向量和强度和夹角有关系的，其结果就是这两个向量的点积。光照模型的计算是在surf方法的表面着色之后，根据输入的光照条件，对原来的颜色在这种光照下的表现进行计算，最后输出新的颜色值给渲染单元完成在屏幕的绘制自定义光照模型，需要先定义一个计算光照的函数，名称格式为Lighting<Your
 Chosen Name>，然后在声明处使用声明：#pragma surface s1 CustomDiffuse。


二、如何操作

修改上一节的代码【Unity Shaders】学习笔记之为表面着色器添加属性(四)
1.将#pragma标记修改为如下代码：
#pragma surface surf BasicDiffuse



2.在SubShader中加入如下代码：
inline float4 LightingBasicDiffuse (SurfaceOutput s, fixed3 lightDir, fixed atten)
{
	float difLight = max(0, dot (s.Normal, lightDir));
	float4 col;
	col.rgb = s.Albedo * _LightColor0.rgb * (difLight * atten * 2);
	col.a = s.Alpha;
	return col;
}



 3.返回到unity窗口，着色器会自动编译。如果没问题，你可以看到材质已经发生了些的变化。


修改前：




修改后：






三、实现原理

 #pragma surface指令告诉着色器将使用哪个光照模型来计算。在我们创建的第一个着色器代码里，默认使用Lighting.cginc文件里包含的Lambert光照模型，所以可以使用这种光照模型来计算。
half4 LightingName(SurfaceOutput s, fixed3 lightDir, fixed atten)
该函数用于不需要视角方向的前向着色
half4 LightingName(SurfaceOutput s, fixed3 lightDir, half3 viewDir,fixed atten)
该函数用户需要视角方向的前向着色
half4 LightingName(SurfaceOutput s, half4 light)

该函数用于需要使用延迟着色的项目
点积函数是cg语言的另一个内置数学函数，我们可以用它来比较两个向量在空间里的方向。点积函数会检查两个向量是互相平行还是互相垂直。任意两个向量都可以通过点积函数获得－1～1的夹角范围，－1表示平行向量并背离你的方向，1表示平行向量，不过是朝着你的方向，0表示和你垂直的方向向量。
为了完成漫反射计算，我们需要将Unity和SurfaceOutput结构体提供我们的数据做乘法运算。为此我们需要乘上s.Albedo和_LightColor0.rgb然后再将结果与difLight * atten相乘，最后返回这个值做颜色值。


四、实现原理

 通过cg标准库中的max函数，我们可以限制点积函数的计算结果。max函数采用两个参数max(arg1,arg2),我们在着色器里使用max函数来确保漫反射的计算结果永远介于0和点积最大值之间。这样你就永远不会得到小于0的值，更不会是－1，否则可能会在你的着色器生成极度黑色区域，并且在之后的运算中容易出现问题。
  在cg标准库函数里还有一个类似的saturate函数，可以帮助我们将浮点值限制在0～1。saturate(和max)两者唯一的区别是saturate可以直接将浮点值转换称饱和度。max函数包含两个参数并返回二者之间的最大值


本章参考《Unity
 Shaders and Effects Cookbook》了一书，感谢原书作者提供的学习资料

SpringMVC页面向controller层传值的自动映射条件，

表单的name值与参数名对应，或使用注解@RequestParam进行对象，或与对象中的属性名对应，并且需要提供setter方法，才能完成参数的赋值，其中是如何进行赋值的过程我们并不知道吗、，也不关心，只知道、如何去使用它就够了，这也就是我们学习效率不高的原因，只知其然，不知其所以然


下面是模拟springMVC向入参为对象中映射值的过程，从此不在Servlet中使用request.getParameter;

条件：

表单name属性的值必须与对象属性名相同
必须提供属性公共的setter方法

在学习的过程中我们要常保持疑问，带着问题去学习，如果你连疑问都没有，那你自然就不知道你想要的答案是什么，没有想要的答案，也就没有学习的价值，先声明你的疑问，再去学习，

疑问：就是为什么需要这两个条件成立

准备代码：一个实体类，一个表单，一个servlet，

package com.entity;

import java.util.Date;
/**
*实体类，将参数值保存在此对象中
*/
public class Student {
    private String name;
    private Integer age;
    private Double score;
    private Date birthDay;
    public Date getBirthDay() {
        return birthDay;
    }
    public void setBirthDay(Date birthDay) {
        this.birthDay = birthDay;
    }
    public Student() {
        System.out.println("Student的无参构造");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
        System.out.println("setName--------》");
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Double getScore() {
        return score;
    }
    public void setScore(Double score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", birthDay=" + birthDay +
                '}';
    }
}


表单 ,注：此处使用的是jsp，name值都与实体类中的属性名对应

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <form action="studentServlet" method="post">
    name: <input type="text" name="name"><br>
    age:<input type="text" name="age"><br>
    score:<input type="text" name="score"><br>
    birthDay: <input type="text" name="birthDay"><br>
    <input type="submit" value="提交"><br>
  </form>
  </body>
</html>


在参数自动映射中，我们也只能在Servlet中进行做文章了，为了代码的重用性，我将参数自动映射功能，封装成一个方法，想要使用只需要将此类拷贝即可，方法的具体内容：

package com.utils;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Enumeration;

public class BeanOperateTools {
	/**
     * 该方法是由Servlet调用
     * 具体实现的参数封装方法
     * @param obj 要将表单值封装至的对象
     * @param req request对象，包含我们表单请求来的数据
     * @throws Exception 可能抛出的异常
     */
    public static void setValueSimple(Object obj, HttpServletRequest req) throws Exception {
    	//得到实体类的类信息
        Class<?> cls = obj.getClass();
        //获取所有的参数名称
        Enumeration<String> enu = req.getParameterNames();
        //遍历参数名称
        while (enu.hasMoreElements()){
   		    //获取参数名称
            String paramName = enu.nextElement();
            //获取对应的参数名称的值
            String paramValue = req.getParameter(paramName);
            //进行判断当前文本框是否填写值，没有值就跳过此属性值的封装
            if("".equals(paramValue) || null==paramValue){
                continue;
            }
            /*根据表单的name值类取得对应的属性，这就是
            为什么需要我们表单的name值要与实体类的属性
            名对应的原因,我们可以根据这个属性的类型，来
            确定setter方法的参数类型，并确定是否需要进
            行类型装换*/
            Field field = cls.getDeclaredField(paramName);
            //获取参数类型,没有包名,getSimpleName()此方法是去除包名的
            String fieldType 
            =field.getType().getSimpleName();
            /*获取指定的操作方法，以满足反射的调用
            使用字符串set+属性名的方式，并把属性的首字母
            大写，正好对应我们属相的setter方法，参数类型
            就是上面的field
            */
            Method method = cls.getMethod("set"+initcap(paramName), field.getType());
            //此处进行判断是否需要进行类型的转换
            if("String".equals(fieldType)){
           		//执行具体set方法，并传入具体值
                method.invoke(obj, paramValue);
            }else if("Integer".equals(fieldType) || "int".equals(fieldType)){
                method.invoke(obj,Integer.parseInt(paramValue));
            }else if("Double".equals(fieldType) || "double".equals(fieldType)){
                method.invoke(obj,Double.parseDouble(paramValue));
            }else if("Date".equals(fieldType)){
                method.invoke(obj,new SimpleDateFormat("yyyy-MM-dd").parse(paramValue));
            }
        }
    }
    //将属性名的首字母大写
    private static String initcap(String value){
        return value.substring(0,1).toUpperCase().concat(value.substring(1));
    }
}


参数封装方法已完成，只需要在Servlet中调用即可

package com.servlet;

import com.entity.Student;
import com.utils.BeanOperateTools;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(name = "StudentServlet", urlPatterns = {"/studentServlet"})
public class StudentServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        //要存储表单数据的对象
        Student stu = new Student();
        try {
        	//直接调用，传入要存储表单数据的对象，和request
            BeanOperateTools.setValueSimple(stu,req);
        } catch (Exception e){
            e.printStackTrace();
        }
        //将封好的数据存入request中，
        req.setAttribute("stu",stu);
        //跳转页面，查看封装的数据是否正确
        req.getRequestDispatcher("show.jsp").forward(req,resp);
    }
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req, resp);
    }
}


show.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${stu}
</body>
</html>

写完这些我们在看一下springMVC的参数自动映射的条件：

表单name属性的值必须与对象属性名相同
必须提供属性公共的setter方法

现在知道为什么了吗！

参数自动映射的具体过程，大致就这些，不知道你看明白了吗，当然，我们所写的与springMVC的相比，那就是，小巫見大巫、木棍挑战坦克，重申：此文章，只是让我们能够了解springMVC在进行参数封装的过程，对框架能够有一个更加深层的认知