一，任务拆分
1.实现哪些功能@select注解，@Param注解，@insert注解...
2.jdbc操作数据库，jdbc技术封装
3.mapper层中的接口怎么调用，如何实例化，mybatis中mapper层都是接口，接口无法被实例化，更不可能调用增删改查的方法
原理说明：
1.相关的注解使用java的自定义注解annotation建立，使用java的反射技术获取类方法上的注解以及相关的参数，再根据注解的不同类型（比如select查询，del删除，insert增加），调用不同的jdbc方法进行数据库操作
2.使用java动态代理技术，生成接口的代理类，实例化代理类，使用代理反射执行增删改查方法
二：核心源码
2.1@select注解，@Param注解，@insert注解
package com.huajie.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface XwfSelect {
String value();
}
package com.huajie.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface XwfInsert {
String value();
}
package com.huajie.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface XwfParam {
String value();
}
2.2jdbc封装工具类,基础的jdbc操作数据库的封装，此类也是网上找的目前不知道出处
package com.huajie.utils;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
public final class JDBCUtils {
private static String connect;
private static String driverClassName;
private static String URL;
private static String username;
private static String password;
private static boolean autoCommit;
/** 声明一个 Connection类型的静态属性，用来缓存一个已经存在的连接对象 */
private static Connection conn;
static {
config();
}
/**
* 开头配置自己的数据库信息
*/
private static void config() {
/*
* 获取驱动
*/
driverClassName = "com.mysql.jdbc.Driver";
/*
* 获取URL
*/
URL = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8";
/*
* 获取用户名
*/
username = "spring1";
/*
* 获取密码
*/
password = "spring1";
/*
* 设置是否自动提交，一般为false不用改
*/
autoCommit = false;
}
/**
* 载入数据库驱动类
*/
private static boolean load() {
try {
Class.forName(driverClassName);
return true;
} catch (ClassNotFoundException e) {
System.out.println("驱动类 " + driverClassName + " 加载失败");
}
return false;
}
/**
* 专门检查缓存的连接是否不可以被使用 ，不可以被使用的话，就返回 true
*/
private static boolean invalid() {
if (conn != null) {
try {
if (conn.isClosed() || !conn.isValid(3)) {
return true;
/*
* isValid方法是判断Connection是否有效,如果连接尚未关闭并且仍然有效，则返回 true
*/
}
} catch (SQLException e) {
e.printStackTrace();
}
/*
* conn 既不是 null 且也没有关闭 ，且 isValid 返回 true，说明是可以使用的 ( 返回 false )
*/
return false;
} else {
return true;
}
}
/**
* 建立数据库连接
*/
public static Connection connect() {
if (invalid()) { /* invalid为true时，说明连接是失败的 */
/* 加载驱动 */
load();
try {
/* 建立连接 */
conn = DriverManager.getConnection(URL, username, password);
} catch (SQLException e) {
System.out.println("建立 " + connect + " 数据库连接失败 , " + e.getMessage());
}
}
return conn;
}
/**
* 设置是否自动提交事务
**/
public static void transaction() {
try {
conn.setAutoCommit(autoCommit);
} catch (SQLException e) {
System.out.println("设置事务的提交方式为 : " + (autoCommit ? "自动提交" : "手动提交") + " 时失败: " + e.getMessage());
}
}
/**
* 创建 Statement 对象
*/
public static Statement statement() {
Statement st = null;
connect();
/* 如果连接是无效的就重新连接 */
transaction();
/* 设置事务的提交方式 */
try {
st = conn.createStatement();
} catch (SQLException e) {
System.out.println("创建 Statement 对象失败: " + e.getMessage());
}
return st;
}
/**
* 根据给定的带参数占位符的SQL语句，创建 PreparedStatement 对象
*
* @param SQL
* 带参数占位符的SQL语句
* @return 返回相应的 PreparedStatement 对象
*/
private static PreparedStatement prepare(String SQL, boolean autoGeneratedKeys) {
PreparedStatement ps = null;
connect();
/* 如果连接是无效的就重新连接 */
transaction();
/* 设置事务的提交方式 */
try {
if (autoGeneratedKeys) {
ps = conn.prepareStatement(SQL, Statement.RETURN_GENERATED_KEYS);
} else {
ps = conn.prepareStatement(SQL);
}
} catch (SQLException e) {
System.out.println("创建 PreparedStatement 对象失败: " + e.getMessage());
}
return ps;
}
public static ResultSet query(String SQL, List<Object> params) {
if (SQL == null || SQL.trim().isEmpty() || !SQL.trim().toLowerCase().startsWith("select")) {
throw new RuntimeException("你的SQL语句为空或不是查询语句");
}
ResultSet rs = null;
if (params.size() > 0) {
/* 说明 有参数 传入，就需要处理参数 */
PreparedStatement ps = prepare(SQL, false);
try {
for (int i = 0; i < params.size(); i++) {
ps.setObject(i + 1, params.get(i));
}
rs = ps.executeQuery();
} catch (SQLException e) {
System.out.println("执行SQL失败: " + e.getMessage());
}
} else {
/* 说明没有传入任何参数 */
Statement st = statement();
try {
rs = st.executeQuery(SQL); // 直接执行不带参数的 SQL 语句
} catch (SQLException e) {
System.out.println("执行SQL失败: " + e.getMessage());
}
}
return rs;
}
private static Object typeof(Object o) {
Object r = o;
if (o instanceof java.sql.Timestamp) {
return r;
}
// 将 java.util.Date 转成 java.sql.Date
if (o instanceof java.util.Date) {
java.util.Date d = (java.util.Date) o;
r = new java.sql.Date(d.getTime());
return r;
}
// 将 Character 或 char 变成 String
if (o instanceof Character || o.getClass() == char.class) {
r = String.valueOf(o);
return r;
}
return r;
}
public static boolean execute(String SQL, Object... params) {
if (SQL == null || SQL.trim().isEmpty() || SQL.trim().toLowerCase().startsWith("select")) {
throw new RuntimeException("你的SQL语句为空或有错");
}
boolean r = false;
/* 表示 执行 DDL 或 DML 操作是否成功的一个标识变量 */
/* 获得 被执行的 SQL 语句的 前缀 */
SQL = SQL.trim();
SQL = SQL.toLowerCase();
String prefix = SQL.substring(0, SQL.indexOf(" "));
String operation = ""; // 用来保存操作类型的 变量
// 根据前缀 确定操作
switch (prefix) {
case "create":
operation = "create table";
break;
case "alter":
operation = "update table";
break;
case "drop":
operation = "drop table";
break;
case "truncate":
operation = "truncate table";
break;
case "insert":
operation = "insert :";
break;
case "update":
operation = "update :";
break;
case "delete":
operation = "delete :";
break;
}
if (params.length > 0) { // 说明有参数
PreparedStatement ps = prepare(SQL, false);
Connection c = null;
try {
c = ps.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
try {
for (int i = 0; i < params.length; i++) {
Object p = params[i];
p = typeof(p);
ps.setObject(i + 1, p);
}
ps.executeUpdate();
commit(c);
r = true;
} catch (SQLException e) {
e.printStackTrace();
System.out.println(operation + " 失败: " + e.getMessage());
rollback(c);
}
} else { // 说明没有参数
Statement st = statement();
Connection c = null;
try {
c = st.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
// 执行 DDL 或 DML 语句，并返回执行结果
try {
st.executeUpdate(SQL);
commit(c); // 提交事务
r = true;
} catch (SQLException e) {
System.out.println(operation + " 失败: " + e.getMessage());
rollback(c); // 回滚事务
}
}
return r;
}
/*
*
* @param SQL 需要执行的 INSERT 语句
*
* @param autoGeneratedKeys 指示是否需要返回由数据库产生的键
*
* @param params 将要执行的SQL语句中包含的参数占位符的 参数值
*
* @return 如果指定 autoGeneratedKeys 为 true 则返回由数据库产生的键； 如果指定 autoGeneratedKeys
* 为 false 则返回受当前SQL影响的记录数目
*/
public static int insert(String SQL, boolean autoGeneratedKeys, List<Object> params) {
int var = -1;
if (SQL == null || SQL.trim().isEmpty()) {
throw new RuntimeException("你没有指定SQL语句，请检查是否指定了需要执行的SQL语句");
}
// 如果不是 insert 开头开头的语句
if (!SQL.trim().toLowerCase().startsWith("insert")) {
System.out.println(SQL.toLowerCase());
throw new RuntimeException("你指定的SQL语句不是插入语句，请检查你的SQL语句");
}
// 获得 被执行的 SQL 语句的 前缀 ( 第一个单词 )
SQL = SQL.trim();
SQL = SQL.toLowerCase();
if (params.size() > 0) { // 说明有参数
PreparedStatement ps = prepare(SQL, autoGeneratedKeys);
Connection c = null;
try {
c = ps.getConnection(); // 从 PreparedStatement 对象中获得 它对应的连接对象
} catch (SQLException e) {
e.printStackTrace();
}
try {
for (int i = 0; i < params.size(); i++) {
Object p = params.get(i);
p = typeof(p);
ps.setObject(i + 1, p);
}
int count = ps.executeUpdate();
if (autoGeneratedKeys) { // 如果希望获得数据库产生的键
ResultSet rs = ps.getGeneratedKeys(); // 获得数据库产生的键集
if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
var = rs.getInt(1); // 获得值并赋值给 var 变量
}
} else {
var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
}
commit(c);
} catch (SQLException e) {
System.out.println("数据保存失败: " + e.getMessage());
rollback(c);
}
} else { // 说明没有参数
Statement st = statement();
Connection c = null;
try {
c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
} catch (SQLException e) {
e.printStackTrace();
}
// 执行 DDL 或 DML 语句，并返回执行结果
try {
int count = st.executeUpdate(SQL);
if (autoGeneratedKeys) { // 如果企望获得数据库产生的键
ResultSet rs = st.getGeneratedKeys(); // 获得数据库产生的键集
if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
var = rs.getInt(1); // 获得值并赋值给 var 变量
}
} else {
var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
}
commit(c); // 提交事务
} catch (SQLException e) {
System.out.println("数据保存失败: " + e.getMessage());
rollback(c); // 回滚事务
}
}
return var;
}
/** 提交事务 */
private static void commit(Connection c) {
if (c != null && !autoCommit) {
try {
c.commit();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/** 回滚事务 */
private static void rollback(Connection c) {
if (c != null && !autoCommit) {
try {
c.rollback();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 释放资源
**/
public static void release(Object cloaseable) {
if (cloaseable != null) {
if (cloaseable instanceof ResultSet) {
ResultSet rs = (ResultSet) cloaseable;
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (cloaseable instanceof Statement) {
Statement st = (Statement) cloaseable;
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (cloaseable instanceof Connection) {
Connection c = (Connection) cloaseable;
try {
c.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}2.3java动态代理
不太了解可以看这篇文章https://blog.csdn.net/xiewenfeng520/article/details/81735484
核心代码
实现InvocationHandler接口
public class MyInvocationHandlerMybatis implements InvocationHandler
反射执行方法invoke，调用接口的时候执行，因为接口被代理了，在代理类中判断方法上注解的类型(CRUD)调用不同的方法
/**
* 代理反射执行
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object reuslt = null;
// reuslt = method.invoke(target, args);
// 判断方法上是否有注解
Annotation[] annotations = method.getAnnotations();
if (null != annotations && annotations.length > 0) {
// Annotation ann = annotations[0];
// 可能有多个注解
for (Annotation annotation : annotations) {
if (annotation instanceof XwfInsert) {
// 添加
reuslt = intsertSql(method, args);
} else if (annotation instanceof XwfDelete) {
// 删除
} else if (annotation instanceof XwfUpdate) {
// 修改
} else if (annotation instanceof XwfSelect) {
// 查询
reuslt = selectSql(method, args);
}
}
}
return reuslt;
}动态代理
// 获取代理对象
@SuppressWarnings("unchecked")
public static <T> T getObjectProxy(Class<T> objSreviceCla) throws Exception {
MyInvocationHandlerMybatis invocationHandlerImpl = new MyInvocationHandlerMybatis(objSreviceCla);
ClassLoader loader = objSreviceCla.getClassLoader();
// Class<?>[] interfaces = objSreviceCla.getInterfaces();
T newProxyInstance = (T) Proxy.newProxyInstance(loader, new Class<?>[] { objSreviceCla },
invocationHandlerImpl);
return newProxyInstance;
}2.4 基础的字符串操作
sql语句的拆分拼接
数据组装，对象或者list
使用反射获取类方法上面注解的参数
完整代码如下：
package com.huajie.orm.mybaits.aop;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.huajie.annotation.XwfDelete;
import com.huajie.annotation.XwfInsert;
import com.huajie.annotation.XwfParam;
import com.huajie.annotation.XwfSelect;
import com.huajie.annotation.XwfUpdate;
import com.huajie.utils.JDBCUtils;
//动态代理
@SuppressWarnings("unused")
public class MyInvocationHandlerMybatis implements InvocationHandler {
// 代理对象
private Object target;
public MyInvocationHandlerMybatis(Object target) {
this.target = target;
}
/**
* 代理反射执行
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object reuslt = null;
// reuslt = method.invoke(target, args);
// 判断方法上是否有注解
Annotation[] annotations = method.getAnnotations();
if (null != annotations && annotations.length > 0) {
// Annotation ann = annotations[0];
// 可能有多个注解
for (Annotation annotation : annotations) {
if (annotation instanceof XwfInsert) {
// 添加
reuslt = intsertSql(method, args);
} else if (annotation instanceof XwfDelete) {
// 删除
} else if (annotation instanceof XwfUpdate) {
// 修改
} else if (annotation instanceof XwfSelect) {
// 查询
reuslt = selectSql(method, args);
}
}
}
return reuslt;
}
/**
* 查询
*
* @param method
* @param args
* @return
*/
private Object selectSql(Method method, Object[] args) {
// 判断方法上是否存在select注解
XwfSelect xwfSelect = method.getAnnotation(XwfSelect.class);
if (null != xwfSelect) {
// 获取注解值 sql语句
String sql = xwfSelect.value();
// 判断sql中是否有参数
if (sql.indexOf("#") > 0) {
// 获取参数 封装成Map
Map<String, Object> parsMap = this.getMethodParsMap(method, args);
// 替换参数封装jdbc能执行的语句
// 根据#{string}参数的顺序 排列 pars里面的顺序 封装成list
List<Object> ListPar = this.getSqlParNameList(sql, parsMap);
// 将sql语句 中的 #{string} 替换成 ?
sql = this.setSqlPars(sql);
// 使用jdbc执行sql语句获取结果
// System.out.println(sql);
// for (Object object : ListPar) {
// System.out.println("参数：" + object.toString());
// }
ResultSet rse = JDBCUtils.query(sql, ListPar);
// 将rse封装成返回对象
return this.selectQueryForObject(method, rse);
} else {
// 没有参数
// 执行sql语句 返回结果 封装成 返回类型
ResultSet rse = JDBCUtils.query(sql, null);
// 将rse封装成返回对象
return this.selectQueryForObject(method, rse);
}
}
// 返回结果
return null;
}
// 将rse封装成返回对象
private Object selectQueryForObject(Method method, ResultSet rse) {
List<Object> listObject = new ArrayList<Object>();
try {
// 判断是否有记录
if (!rse.next()) {
return null;
}
// 光标往上移动一位
rse.previous();
String reutrnTypeFlag = "Bean";
// 将结果封装成方法的返回类型
Class<?> returnType = method.getReturnType();
// 判断返回类型为List还是JavaBean
// 如果为List 再获取List中泛型的值
Type genericReturnType = method.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) genericReturnType;
Type rType = pType.getRawType();// 主类型
Type[] tArgs = pType.getActualTypeArguments();// 泛型类型
for (int i = 0; i < tArgs.length; i++) {
System.out.println(pType + "第" + i + "泛型类型是：" + tArgs[i]);
returnType = Class.forName(tArgs[i].getTypeName());
reutrnTypeFlag = "List";
}
}
// 设置每条记录的属性值
while (rse.next()) {
Object returnInstance = returnType.newInstance();
// 获取实例的字段属性
Field[] declaredFields = returnInstance.getClass().getDeclaredFields();
for (Field field : declaredFields) {
// 获取光标值
Object value = rse.getObject(field.getName());
// 获取set方法对象
Method methodSet = returnInstance.getClass().getMethod("set" + toUpperCaseFirstOne(field.getName()),
field.getType());
field.setAccessible(true);
// 为返回结果实例设置值
methodSet.invoke(returnInstance, value);
}
listObject.add(returnInstance);
}
// 如果返还对象为List
if (reutrnTypeFlag.equals("List")) {
return listObject;
} else {
// 如果返还对象为普通bean
return listObject.get(0);
}
} catch (Exception e) {
throw new RuntimeException("返回类型反射生成实例失败", e);
}
}
// 首字母转小写
public static String toLowerCaseFirstOne(String s) {
if (Character.isLowerCase(s.charAt(0)))
return s;
else
return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
}
// 首字母转大写
public static String toUpperCaseFirstOne(String s) {
if (Character.isUpperCase(s.charAt(0)))
return s;
else
return (new StringBuilder()).append(Character.toUpperCase(s.charAt(0))).append(s.substring(1)).toString();
}
/**
* 插入
*
* @param method
* @param args
*
* @return
*/
public Object intsertSql(Method method, Object[] args) {
// 判断方法上是否存在insert注解
XwfInsert xwfInsert = method.getAnnotation(XwfInsert.class);
if (null != xwfInsert) {
// 获取注解值 sql语句
String sql = xwfInsert.value();
// 判断sql中是否有参数
if (sql.indexOf("#") > 0) {
// 获取参数 封装成Map
Map<String, Object> parsMap = this.getMethodParsMap(method, args);
// 替换参数封装jdbc能执行的语句
// 根据#{string}参数的顺序 排列 pars里面的顺序 封装成list
List<Object> ListPar = this.getSqlParNameList(sql, parsMap);
// 将sql语句 中的 #{string} 替换成 ?
sql = this.setSqlPars(sql);
// 使用jdbc执行sql语句获取结果
System.out.println(sql);
for (Object object : ListPar) {
System.out.println("参数：" + object.toString());
}
return JDBCUtils.insert(sql, false, ListPar);
} else {
// 没有参数
return JDBCUtils.execute(sql);
}
}
// 返回结果
return false;
}
// 截取sql中的参数并封装成map集合
private List<Object> getSqlParNameList(String sql, Map<String, Object> parsMap) {
List<Object> ListPar = new ArrayList<Object>();
// 获取参数
List<String> listPars = this.getSqlParsList(sql);
// 获取设置jdbc参数 按顺序
for (String string : listPars) {
ListPar.add(parsMap.get(string));
}
return ListPar;
}
// 获取sql中#{}中的参数名称
private List<String> getSqlParsList(String sql) {
List<String> ListPar = new ArrayList<String>();
if (sql.indexOf("#") > 0) {
// sql = sql.trim();
// 获取到}位置
int indexNext = sql.indexOf("#") + sql.substring(sql.indexOf("#")).indexOf("}");
// 获取到{位置
int indexPre = sql.indexOf("#") + sql.substring(sql.indexOf("#")).indexOf("{");
// 截取#{}中的值
String parName = sql.substring(indexPre + 1, indexNext);
ListPar.add(parName.trim());
sql = sql.substring(indexNext + 1);
if (sql.indexOf("#") > 0) {
ListPar.addAll(getSqlParsList(sql));
}
}
return ListPar;
}
/**
* 将sql中替换参数为?
*
* @param sql
* @return
*/
private String setSqlPars(String sql) {
List<String> ListPar = new ArrayList<String>();
if (sql.indexOf("#") > 0) {
// 获取到}位置
int indexNext = sql.indexOf("#") + sql.substring(sql.indexOf("#")).indexOf("}");
// 获取到{位置
int indexPre = sql.indexOf("#");
// 截取#{}中的值
String parName = sql.substring(indexPre, indexNext + 1);
ListPar.add(parName.trim());
sql = sql.replace(parName, "?");
if (sql.indexOf("#") > 0) {
sql = setSqlPars(sql);
}
}
return sql;
}
public static void main(String[] args) {
String sql = "insert into test_sort values (# { username3},#{username1},#{username2}) ";
// List<String> l = getSqlParsList(sql);
// for (String str : l) {
// System.out.println(str);
// }
// sql = setSqlPars(sql);
// System.out.println(sql);
}
/**
* 获取方法里面的参数和param注解中的value值封装成map对象
*
* @param args
* @return
*/
private Map<String, Object> getMethodParsMap(Method method, Object[] args) {
Map<String, Object> parsMap = new HashMap<String, Object>();
Parameter[] parameters = method.getParameters();
for (int i = 0; i < parameters.length; i++) {
Parameter parameter = parameters[i];
// 获取方法参数中是否存在param注解
XwfParam xwfParam = parameter.getAnnotation(XwfParam.class);
String parName = "";
// 获取param注解中value的值
if (null != xwfParam) {
parName = xwfParam.value();
} else {
parName = parameter.getName();
}
// 将参数名称和参数封装成map集合
parsMap.put(parName, args[i]);
}
return parsMap;
}
// 获取代理对象
@SuppressWarnings("unchecked")
public static <T> T getObjectProxy(Class<T> objSreviceCla) throws Exception {
MyInvocationHandlerMybatis invocationHandlerImpl = new MyInvocationHandlerMybatis(objSreviceCla);
ClassLoader loader = objSreviceCla.getClassLoader();
// Class<?>[] interfaces = objSreviceCla.getInterfaces();
T newProxyInstance = (T) Proxy.newProxyInstance(loader, new Class<?>[] { objSreviceCla },
invocationHandlerImpl);
return newProxyInstance;
}
}
最后一步测试：
mapper层
package com.huajie.mapper;
import java.util.List;
import com.huajie.annotation.XwfInsert;
import com.huajie.annotation.XwfParam;
import com.huajie.annotation.XwfSelect;
import com.huajie.model.TestBean;
public interface UserMapper {
@XwfInsert(value = "insert into test_sort values (#{username}) ")
public int add(@XwfParam(value = "username") String username);
@XwfSelect(value = "select * from test_user where username = #{username} ")
public List<TestBean> select(@XwfParam(value = "username") String username);
@XwfSelect(value = "select * from test_user where username = #{username} ")
public TestBean selectForBean(@XwfParam(value = "username") String username);
}
javabean
package com.huajie.model;
public class TestBean {
private String username;
private String password;
public TestBean() {
super();
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "TestBean [username=" + username + ", password=" + password + "]";
}
}
测试类
package com.huajie;
import java.util.List;
import com.huajie.mapper.UserMapper;
import com.huajie.model.TestBean;
import com.huajie.orm.mybaits.aop.MyInvocationHandlerMybatis;
/**
* @author Administrator
* 1.接口实例化 Mapping接口方法和sql语句进行绑定
* 2.aop在接口调用前 实例化 将实例对象 赋值给接口对象即可
* ##1.使用字节码技术创建虚拟子类
* 2.使用匿名内部类的方式
* 3.使用AOP
*/
public class Test001 {
public static void main(String[] args) throws Exception {
UserMapper objectProxy = MyInvocationHandlerMybatis.getObjectProxy(UserMapper.class);
// objectProxy.add("1");
List<TestBean> select = objectProxy.select("1");
for (TestBean testBean : select) {
System.out.println(testBean);
}
System.out.println("=================================");
TestBean bean = objectProxy.selectForBean("1");
System.out.println(bean);
}
}
测试截图
