关于如何在项目中实现以注解的方式添加数据库字段

最新推荐文章于 2024-05-02 09:01:23 发布
原创 最新推荐文章于 2024-05-02 09:01:23 发布 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍如何使用自定义注解MyColumn配合MyBatis框架，实现实体类字段与数据库表字段的自动同步。通过在实体类中添加注解属性，系统能自动检测并创建数据库中缺失的字段。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、首先新建一个包annotation，在这个包下面写一个类MyColumn

package hry.utils.annotation;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * 拓展下Column
 * 
 */
@Target({METHOD, FIELD}) 
@Retention(RUNTIME)
public @interface MyColumn {

    String name() default "";

    boolean unique() default false;

    boolean nullable() default true;

    boolean insertable() default true;

    boolean updatable() default true;

    String columnDefinition() default "";

    String table() default "";

    int length() default 255;

    int precision() default 0;

    int scale() default 0;

    String comment() default "";
    
    String type() default "varchar";
}

这个类就相当于数据库的实体

二、再建一个mybatis的包 里面新建4个类分别是AnnotationUtil、ClassUtil、DBHelper、MybatisGeneration

AnnotationUtil类

package hry.utils.mybatis;

import org.apache.log4j.Logger;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.List;
import java.util.Properties;


public class AnnotationUtil {
    public static Properties jdbc;
    private static Logger logger = Logger.getLogger(AnnotationUtil.class);
    public static void validAnnotation(List<Class<?>> clsList) {
        InputStream insjdbc = AnnotationUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
        jdbc = new Properties();
        try {
            jdbc.load(insjdbc);
        } catch (IOException e) {
            e.printStackTrace();
        }


        //开始加字段
        Long start = System.currentTimeMillis();
        if (clsList != null && clsList.size() > 0) {

            for (Class<?> forName : clsList) {
                if (forName != null) {
                    Field[] fs = forName.getDeclaredFields();


                    //先拿到@Table
                    Table annotationTable = forName.getAnnotation(Table.class);
                    String columns = "";
                    if (annotationTable != null) {
                        String name = "";
                        try {
                            name = annotationTable.name();
                            columns = DBHelper.getColumns(name);
                        } catch (Exception e) {
                            e.printStackTrace();
                            logger.error(name);
                            continue;
                        }

                    } else {//如果不是实体类直接跳过
                        continue;
                    }

                    if (!"".equals(columns) && null != columns) {
                        for (Field field : fs) {
                            if (!field.isAccessible()) {
                                field.setAccessible(true);
                            }
                            StringBuffer sb = new StringBuffer("ALTER TABLE " + annotationTable.name() + " ADD ");

                            //取字段上@Column的name
                            Column annotationColumn = field.getAnnotation(Column.class);
                            if (annotationColumn != null) {
                            	try {
                                    if (!"".equals(annotationColumn.name()) && !columns.contains(annotationColumn.name()) && annotationColumn.columnDefinition() != null && (!"".equals(annotationColumn.columnDefinition()))) {
                                        //如果不包含，说明这个字段实体有，数据库没有
                                    	logger.error(annotationColumn.name());
                                        //先创建这个字段
                                        sb.append(annotationColumn.name() + " ");
                                        //判断类型
                                        sb.append(annotationColumn.columnDefinition());


                                        //是否为空
                                        /*if (annotationColumn.nullable()) {
                                            sb.append("DEFAULT NULL ");
                                        } else {
                                            sb.append("DEFAULT NOT NULL ");
                                        }*/
                                        //是否唯一
                                        /*if (annotationColumn.unique()) {
                                            sb.append("UNIQUE ");
                                        }
*/
                                        logger.error("sql  ==  " + sb.toString());
                                        DBHelper.execute(sb.toString());
                                        //logger.error(sb);

                                        //字段上是否含有@Id 和 @GeneratedValue,一般这两个字段是一起用的
                                        Id annotationId = field.getAnnotation(Id.class);
                                        GeneratedValue annotationGeneratedValue = field.getAnnotation(GeneratedValue.class);
                                        if (annotationId != null && annotationGeneratedValue != null) {
                                            String sql = "alter table " + annotationTable.name() + " change " + annotationColumn.name() + " " + annotationColumn.name() + " " + annotationColumn.columnDefinition() + " AUTO_INCREMENT PRIMARY KEY";
                                            DBHelper.execute(sql.toString());
                                            logger.error(sql);
                                        }
                                    }
								} catch (Exception e) {
									//e.printStackTrace();
									logger.error(annotationTable.name());
								}
                      
                            }
                        }
                    }
                }
            }
        }
        logger.error("加字段结束,耗时" + (System.currentTimeMillis() - start) / 1000 + "秒");
    }
}

ClassUtil类

package hry.utils.mybatis;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.regex.Pattern;

public class ClassUtil {

    /**
     * 通过包名获取包内所有类 
     *
     * @param pkg
     * @return
     */
    public static List<Class<?>> getAllClassByPackageName(String pkg) {
        //String packageName = pkg.getName();
        // 获取当前包下以及子包下所以的类  
        List<Class<?>> returnClassList = getClasses(pkg);
        return returnClassList;
    }

    /**
     * 通过接口名取得某个接口下所有实现这个接口的类 
     */
    public static List<Class<?>> getAllClassByInterface(Class<?> c) {
        List<Class<?>> returnClassList = null;

        if (c.isInterface()) {
            // 获取当前的包名  
            String packageName = c.getPackage().getName();
            // 获取当前包下以及子包下所以的类  
            List<Class<?>> allClass = getClasses(packageName);
            if (allClass != null) {
                returnClassList = new ArrayList<Class<?>>();
                for (Class<?> cls : allClass) {
                    // 判断是否是同一个接口  
                    if (c.isAssignableFrom(cls)) {
                        // 本身不加入进去  
                        if (!c.equals(cls)) {
                            returnClassList.add(cls);
                        }
                    }
                }
            }
        }

        return returnClassList;
    }

    /**
     * 取得某一类所在包的所有类名 不含迭代 
     */
    public static String[] getPackageAllClassName(String classLocation, String packageName) {
        // 将packageName分解  
        String[] packagePathSplit = packageName.split("[.]");
        String realClassLocation = classLocation;
        int packageLength = packagePathSplit.length;
        for (int i = 0; i < packageLength; i++) {
            realClassLocation = realClassLocation + File.separator + packagePathSplit[i];
        }
        File packeageDir = new File(realClassLocation);
        if (packeageDir.isDirectory()) {
            String[] allClassName = packeageDir.list();
            return allClassName;
        }
        return null;
    }

    /**
     * 从包package中获取所有的Class 
     *
     * @param
     * @return
     */
    private static List<Class<?>> getClasses(String packageName) {

        // 第一个class类的集合  
        List<Class<?>> classes = new ArrayList<Class<?>>();
        // 是否循环迭代  
        boolean recursive = true;
        // 获取包的名字 并进行替换  
        String packageDirName = packageName.replace('.', '/');
        // 定义一个枚举的集合 并进行循环来处理这个目录下的things  
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            // 循环迭代下去  
            while (dirs.hasMoreElements()) {
                // 获取下一个元素  
                URL url = dirs.nextElement();
                // 得到协议的名称  
                String protocol = url.getProtocol();
                // 如果是以文件的形式保存在服务器上  
                if ("file".equals(protocol)) {
                    // 获取包的物理路径  
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    // 以文件的方式扫描整个包下的文件 并添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                } else if ("jar".equals(protocol)) {
                    // 如果是jar包文件  
                    // 定义一个JarFile  
                    JarFile jar;
                    try {
                        // 获取jar  
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        // 从此jar包 得到一个枚举类  
                        Enumeration<JarEntry> entries = jar.entries();
                        // 同样的进行循环迭代  
                        while (entries.hasMoreElements()) {
                            // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件  
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 如果是以/开头的  
                            if (name.charAt(0) == '/') {
                                // 获取后面的字符串  
                                name = name.substring(1);
                            }
                            // 如果前半部分和定义的包名相同  
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                // 如果以"/"结尾 是一个包  
                                if (idx != -1) {
                                    // 获取包名 把"/"替换成"."  
                                    packageName = name.substring(0, idx).replace('/', '.');
                                }
                                // 如果可以迭代下去 并且是一个包  
                                if ((idx != -1) || recursive) {
                                    // 如果是一个.class文件 而且不是目录
                                    String pattern = "hry/[a-zA-Z]*/[a-zA-Z]*/model/[a-zA-Z]*\\.class";
                                    if (name.endsWith(".class") && !entry.isDirectory()) {

                                        if(!name.contains("model")){
                                            continue;
                                        }
                                        if(!Pattern.matches(pattern, name)){
                                            continue;
                                        }

                                        // 去掉后面的".class" 获取真正的类名
                                        String className = name.substring(packageName.length() + 1, name.length() - 6);
                                        try {
                                            // 添加到classes  
                                            classes.add(Class.forName(packageName + '.' + className));
                                        } catch (ClassNotFoundException e) {
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return classes;
    }

    /**
     * 以文件的形式来获取包下的所有Class 
     *
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    private static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, List<Class<?>> classes) {
        // 获取此包的目录 建立一个File  
        File dir = new File(packagePath);
        // 如果不存在或者 也不是目录就直接返回  
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }
        // 如果存在 就获取包下的所有文件 包括目录  
        File[] dirfiles = dir.listFiles(new FileFilter() {
            // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)  
            public boolean accept(File file) {
                return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
            }
        });
        // 循环所有文件  
        for (File file : dirfiles) {
            // 如果是目录 则继续扫描  
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, classes);
            } else {
                // 如果是java类文件 去掉后面的.class 只留下类名
                String name = file.getPath();
                if(!name.contains("model")){
                    continue;
                }
                String pattern = "hry/[a-zA-Z]*/[a-zA-Z]*/model/[a-zA-Z]*\\.class";
                String clName = name.replace("\\","/").split("classes")[1].substring(1);
                if(!Pattern.matches(pattern,clName)){
                    continue;
                }
                String className = file.getName().substring(0, file.getName().length() - 6);
                try {
                    // 添加到集合中去
                    classes.add(Class.forName(packageName + '.' + className));
                } catch (ClassNotFoundException e) {
                    //e.printStackTrace();
                    //System.out.println("类"+className+"不存在");
                }
            }
        }
    }

    public static void main(String[] args) {
        List<Class<?>> clsList = ClassUtil.getAllClassByPackageName("hry");

        AnnotationUtil.validAnnotation(clsList);
    }
}

DBHelper类

package hry.utils.mybatis;

import org.apache.log4j.Logger;

import java.sql.*;

public class DBHelper {
    public static final String name = "com.mysql.jdbc.Driver";
    private static Logger logger = Logger.getLogger(DBHelper.class);
    public Connection conn = null;
    public PreparedStatement pst = null;

    public DBHelper(String sql) {
        try {
            Class.forName(name);//指定连接类型
            conn = DriverManager.getConnection(AnnotationUtil.jdbc.getProperty("jdbc.url"), AnnotationUtil.jdbc.getProperty("jdbc.username"), AnnotationUtil.jdbc.getProperty("jdbc.password"));//获取连接
            pst = conn.prepareStatement(sql);//准备执行语句
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void close() {
        try {
            this.conn.close();
            this.pst.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void execute(String sql){
        try {
            DBHelper db = new DBHelper(sql);
            db.pst.execute();
            db.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static String getColumns(String tableName){
        DBHelper db = new DBHelper("show full columns from "+tableName+" ");
        StringBuffer sb = new StringBuffer();
        try {
            ResultSet ret = db.pst.executeQuery();
            while (ret.next()) {
                sb.append(ret.getString(1) + ",");
            }
            ret.close();
            db.close();//关闭连接
            return sb.deleteCharAt(sb.length()-1).toString();
        } catch (SQLException e) {
            //e.printStackTrace();
            logger.error("表"+tableName+"不存在");
        }
        return null;
    }
}

MybatisGeneration类

package hry.utils.mybatis;

import hry.utils.annotation.MyColumn;
import org.apache.log4j.Logger;
import org.springframework.util.StringUtils;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.Properties;


/**
 * 
 * MybatisGeneration.java
 */
public class MybatisGeneration {
	private static Logger logger = Logger.getLogger(MybatisGeneration.class);
	public static Properties jdbc;

	public static void generation(){
		InputStream insjdbc = MybatisGeneration.class.getClassLoader().getResourceAsStream("jdbc.properties");
        jdbc = new Properties();
        try {
            jdbc.load(insjdbc);
        } catch (IOException e) {
            e.printStackTrace();
        }
		
		InputStream ins = MybatisGeneration.class.getClassLoader().getResourceAsStream("code.properties");
		Properties pro = new Properties();
		try {
			pro.load(ins);
		} catch (IOException e) {
			e.printStackTrace();
		}
		String modelUrl = pro.getProperty("modelUrl");
		
		if(!StringUtils.isEmpty(modelUrl)){
			logger.error("modelUrl  ==  " + modelUrl);
			
			String[] str = modelUrl.split(",");
			if(str.length>0){
				try {
					for(int i=0;i<str.length;i++){
						Class<?> forName = Class.forName(str[i]);
						if(forName!=null){
							Field[] fs = forName.getDeclaredFields();
							
							//先拿到@Table
							Table annotationTable = forName.getAnnotation(Table.class);
							String columns = "";
							if(annotationTable!=null){
								columns = DBHelper.getColumns(annotationTable.name());
							}
							
							if(!"".equals(columns)){
								for(Field field : fs){
									if(!field.isAccessible()){  
										field.setAccessible(true);  
					                }
									StringBuffer sb = new StringBuffer("ALTER TABLE "+ annotationTable.name() +" ADD ");
									
									//取字段上@MyColumn的name
									MyColumn annotationColumn = field.getAnnotation(MyColumn.class);
									if(annotationColumn!=null){
										if(!"".equals(annotationColumn.name()) && !columns.contains(annotationColumn.name())){
											//如果不包含，说明这个字段实体有，数据库没有
											
											//先创建这个字段
											sb.append(annotationColumn.name() +" ");
											//判断类型
											if("text".equals(annotationColumn.type())){
												sb.append(annotationColumn.type());
											}else if("datetime".equals(annotationColumn.type())){
												sb.append("datetime ");
											}else if("decimal".equals(annotationColumn.type())){
												sb.append("DECIMAL(" + annotationColumn.precision() + "," + annotationColumn.scale() + ") ");
											}else{
												sb.append("" + annotationColumn.type() + "("+ annotationColumn.length() +") ");
											}
											//是否为空
											if(annotationColumn.nullable()){
												sb.append("DEFAULT NULL ");
											}else{
												sb.append("DEFAULT NOT NULL ");
											}
											//是否唯一
											if(annotationColumn.unique()){
												sb.append("UNIQUE ");
											}
											//注释
											if(!"".equals(annotationColumn.comment())){
												sb.append("COMMENT '"+ annotationColumn.comment() +"'");
											}
											logger.error("sql  ==  " + sb.toString());
											DBHelper.execute(sb.toString());
											
											//字段上是否含有@Id 和 @GeneratedValue,一般这两个字段是一起用的
											Id annotationId = field.getAnnotation(Id.class);
											GeneratedValue annotationGeneratedValue = field.getAnnotation(GeneratedValue.class);
											if(annotationId!=null && annotationGeneratedValue!=null){
												String sql = "alter table "+ annotationTable.name() +" change "+ annotationColumn.name() +" "+ annotationColumn.name() +" "+ annotationColumn.type() +" AUTO_INCREMENT PRIMARY KEY";
												DBHelper.execute(sql.toString());
											}
										}
									}
								}
							}
						}
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	public static void main(String[] args) {
		MybatisGeneration.generation();
	}
}

三、在定时器中添加代码如下

        //扫描实体类，配置注解可生成字段
        List<Class<?>> clsList = ClassUtil.getAllClassByPackageName("hry");  
        AnnotationUtil.validAnnotation(clsList);

在这里插入图片描述
、
这个“”里面填你的总包名 例如本地的main中新建有hry包，这个就会扫描你这个包里面的所有实体类

四、在实体类中添加注解属性

在这里插入图片描述

然后只要在实体类中配有属性columnDefinition 就能根据类去生成字段了
@Column(name= “address”, columnDefinition= “varchar(255) DEFAULT NULL COMMENT ‘地址’”)

字节码增强——使用javassist生成一个类的复制类并添加字段和注解
a624193873的博客
02-07 2741
一、Javassist简介 是在 Java 中编辑字节码的类库。 它使 Java 程序能够在运行时定义一个新类, 并在 JVM 加载时修改类文件。 二、和反射的区别 反射的定义：是让程序在运行时，能够动态获取或修改对象的所有成员变量，调用对象的所有方法。 可以看到反射只可以获取和修改成员变量，可以调用方法，但不能修改方法。如果想要修改方法、新增属性就要使用到字节码增强技术，即：Javassist，可以通过修改字节码的方式来实现对类结构的修改。 三、背景介绍 用到这个技术是因为产品提了一个需求，要做一
Mybatis-使用注解开发实现数据库增删改查
wqs6666的博客
05-30 193
我们可以在编写工具类时完成事务提交！ 1.mybatis-config配置文件 <?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> <s
Spring AOP通过@DeclareParents注解为对象新增方法
Jaemon
11-20 309
Spring AOP通过@DeclareParents注解为对象新增方法
lombok之使用注解添加实体类的方法
hyly_zhard的博客
11-21 1489
lombok是一个第三方的jar包，要使用该包的注解，需要先在pom中添加lombok的依赖。 @Data:注解在类上，给类提供了set，get，equasl，toString，hashCode等方法。 @NoArgsConstructor：给类添加一个无参数的构造方法。 @AllArgsConstructor：给类添加一个全参的构造方法。 @Accessors(chain=true)：让该类的实...
java 添加字段,向Java类添加字段
weixin_33034073的博客
02-12 740
Looked at using CGLib, ASM, BCEL (aspect) and Javassist to add a field to a class during runtime....Just to get my head straight it looks like these bytecode manipulators don't update the actual class...
【Java EE】MyBatis使用注解操作数据库
ZXT的博客
05-02 1398
MyBatis使用注解操作数据库，参数传递，MyBatis使用注解实现增删改查，结果映射，开启驼峰命名(推荐)
Mybatis generator 生成中文注释/lombok注解（使用数据库字段注释）
吾生也有涯，而知也无涯
02-11 2983
目录快速开始初始化sql使用前使用后pom.xml配置generator的config.xml在idea的插件中使用插件源码 快速开始 初始化sql 数据库的建表sql CREATE TABLE `user` ( `id` bigint(20) DEFAULT NULL COMMENT '自增id', `name` varchar(255) DEFAULT NULL COMMENT '姓名...
mybatis拦截器实现通用权限字段添加的方法
08-25
在intercept方法中，我们可以获取当前执行的SQL语句，并将其修改以添加通用权限字段。 ```java String sql = getSqlByInvocation(invocation); if (sql.contains("commonEnShortCode")) { sql = ...
hibernate@注解方式配置实体类，调用javadoc接口生成数据库表及字段的注释说明
06-23
hibernate@注解方式配置实体类时，利用javadoc接口生成数据库表及字段的注释说明，支持oracle、sqlserver、db2、mysql数据库。因用到java\lib\tools.jar，需要将该jar放入工程lib下(或者tomcat\lib下、或加入...
使用mybatis插件mybatis-generator 自动生成lombok注解,去除get和set方法,自动为实体添加数据库字段的注释
weixin_55586010的博客
03-01 1989
1.pom文件依赖2.generator.xml文件注意：generator.xml文件中的标签是有顺序的 顺序不对会报错的 关于lombok的配置在plugin标签中。
java 通过反射获取类上注解，方法上注解，注解里的值及方法参数
10-09
java 通过反射获取类上注解，方法上注解，注解里的值及方法参数，项目为maven项目。导入时记得选择maven项目
Java注解的分类及通过自定义Java注解实现数据库的操作
winwinwin99的博客
03-28 499
在Java程序中通过注解，可以让编程更加简洁、代码更加清晰。因此在Java框架代码中，嵌入了大量的注解。 讲注解，首先得讲注解的概念：Java提供了一种原程序中的元素关联任何信息和任何元数据的途径和方法。 一、注解的分类 1、按照运行机制分为源码注解、编译注解和运行时注解 （1）源码注解：注解只在源码中存在，编译成.class文件就不存在了 （2）编译注解：注解在源码和.class文件...
MyBatis使用注解进行数据库表增删查改
wuzhongrui的博客
07-18 377
MyBatis使用注解进行数据库增删查改
Java注解代码生成
浅谈Android
09-26 3382
Java注解代码生成 最近本着不求甚解的态度重温了一下主流框架的源码，所以趁热打铁的总结一下，学习框架或开发框架所必备的基础知识： Java反射 Java注解 注解代码自动生成 Java动态代理 AOP 简介 在我们常用的框架中注解和自动生成代码的身影很常见，因为注解和自动生成的配合，从而简化和统一代码，使框架使用简单且容易扩展，典型且最熟悉的就是ButterKnife，主要功能利用注解省略了...
动态的为实体字段添加注解/注解属性
热门推荐
Adda_Chen的博客
06-29 1万+
可以动态的给实体添加注解，比如：导出表格的时候，根据条件决定是否导出该字段的列等使用 本例子将所有代码都放入工具类中，实际上有些不能实例化到内存中，只能作为一部分代码放在逻辑中，此种代码以再程序中标注；另一部分是可以持久化到内存，使用完工具类之后也可以继续保存注解或者属性； 使用搭配在文末指出 代码如下： package com.springcloud.utils; import org.apache.ibatis.javassist.ClassPool; import org.apache.ibatis
spring核心之一 AOP
qq_30136729的博客
05-15 268
AOP 一.概念： 面向切编程：使用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个之间的耦合度降低，提高程序的可重用性，提高了开发效率。 不通过修改代码方式，添加新的功能（新功能单独写一个模块，通过方式加入其中，不改变原来的模块代码） 二.底层原理： 1.Aop底层使用动态代理 有两种情况： 有接口情况，使用JDK代理 创建接口实现类代理对象，增强类的方法 没有接口情况，使用CGLIB动态代理 创建子类的代理对象，增强类的方法 2.JDK动态代理过程 使用Proxy类里面的方法创建代理
增加临时字段_ @Entity @Table 实体类中增加临时字段时(实体类中需要，但在数据库中不存在)时需要添加注解？？？
小时候超帅的博客
04-19 3559
当我们使用spring data jpa开发的时候，会将实体类中的成员变量与表中的字段一一对应，当我们在实体类中加上一个不与数据库表一一对应的成员变量的时候，此时我们只要在这个成员变量上加上注解@Transient @Transient表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性. 如果一个属性并非数据库表的字段映射,务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic 比如现在有实体类Message,但是我想在使用它时想要多用一个字段来接收未读消息的数量 u.
实体类属性或传入参数中的常用注解
xijingcc的博客
09-16 3230
@Tag 放入缓存的实体类在每个属性上加@Tag注释，根据Tag里面的值来进行序列化的，顺序一旦确定了就不能变，否则反序列化会找不到。 javax.validation.constraints 数据校验，会根据对应属性的注解对前端传入参数做判断，常见的有@NotNull,@NotEmpty,@NotBlank ...
java 动态添加字段 以及 动态新增字段注解
qq_39838930的博客
09-14 9721
java 动态添加字段 以及 动态新增字段注解
使用注解实现数据库字段映射实体属性
最新发布
07-25
<think>我们正在讨论使用Java注解来实现数据库字段与实体类属性的映射。根据引用内容，我们可以使用JPA（Java Persistence API）或Hibernate提供的注解来完成这一任务。常见的注解包括`@Entity`, `@Table`, `@Id`, `@Column`等。 步骤： 1. 创建实体类，并使用`@Entity`注解标记该类，表示这是一个持久化实体。 2. 使用`@Table`注解指定对应的数据库表名（如果表名与类名不一致）。 3. 在类的属性上使用`@Column`注解来映射数据库字段，如果字段名与属性名不一致，可以通过`name`属性指定数据库字段名。 4. 使用`@Id`注解标记主键字段，并可以选择主键生成策略（如`@GeneratedValue`）。 另外，如果数据库字段是下划线命名，而实体类属性是驼峰命名，JPA默认会自动进行转换（如`user_name`映射到`userName`）。如果不需要转换或者命名不一致，我们可以通过`@Column`注解显式指定。 根据引用[3]，我们也可以自己编写一个工具方法将数据库字段名转为驼峰命名的属性名，但在使用JPA时，通常不需要手动转换，因为JPA提供者（如Hibernate）默认支持这种命名策略。 下面是一个使用注解映射的示例： ```java import javax.persistence.*; @Entity @Table(name = "user_table") // 如果表名与类名不同，则用此注解指定表名 public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; // 如果数据库字段名为user_name，而属性名为userName，可以不加注解，因为默认命名策略会转换 // 但也可以显式指定 @Column(name = "user_name") private String userName; // 如果数据库字段和属性名相同（比如都是email），可以不加@Column注解 private String email; // 省略getter和setter } ``` 在这个例子中： - `@Entity`表示这是一个实体类。 - `@Table(name = "user_table")`指定了对应的数据库表名为`user_table`。 - `@Id`和`@GeneratedValue`用于标识主键及其生成策略。 - `@Column(name = "user_name")`显式地将数据库字段`user_name`映射到属性`userName`。如果数据库字段名和属性名遵循驼峰和下划线的对应关系，可以省略这个注解。 注意事项： - 需要确保添加了JPA或Hibernate的依赖。 - 在配置文件中（如`persistence.xml`或Spring Boot的`application.properties`）配置数据源和JPA相关属性。 如果使用Spring Boot，可以在`application.properties`中配置： ```properties spring.datasource.url=jdbc:mysql://localhost:3306/mydb spring.datasource.username=root spring.datasource.password=123456 spring.jpa.hibernate.ddl-auto=update spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect ``` 这样，我们就完成了数据库字段到实体类属性的映射。 §§相关问题§§ 1. JPA中除了`@Column`还有哪些常用的映射注解？ 2. 如何配置JPA的命名策略以实现自动的下划线转驼峰？ 3. 在Spring Boot中如何配置多数据源并分别指定实体类包路径？ 4. JPA的`@GeneratedValue`有哪些生成策略？分别适用于什么场景？</think>### Java 注解实现数据库字段与实体类属性映射 在 Java 中，可以通过 JPA（Java Persistence API）提供的注解实现数据库字段到实体类属性的映射。以下是具体实现步骤和代码示例： #### 1. **基础映射注解** ```java import javax.persistence.*; @Entity @Table(name = "user") // 指定数据库表名 public class User { @Id // 标记为主键 @GeneratedValue(strategy = GenerationType.IDENTITY) // 主键生成策略 private Long id; @Column(name = "user_name") // 映射字段名 private String username; @Column(name = "email_address") private String email; // 省略 getter/setter } ``` - **`@Entity`**：声明为持久化实体类 - **`@Table`**：指定对应的数据库表名 - **`@Id`**：标记主键字段 - **`@Column`**：自定义字段映射（`name`属性解决命名不一致问题） #### 2. **自动驼峰命名映射（无需`@Column`）** 当数据库字段为下划线格式（如 `user_name`），实体类属性为驼峰格式（如 `userName`）时，JPA 默认支持自动转换： ```java @Entity public class Product { @Id private Long id; private String productName; // 自动映射到 product_name 字段 private Integer stockCount; // 自动映射到 stock_count 字段 } ``` #### 3. **高级映射注解 ```java // 枚举类型映射 @Enumerated(EnumType.STRING) private UserStatus status; // 存储枚举名称（如 "ACTIVE"） // 日期类型映射 @Temporal(TemporalType.TIMESTAMP) private Date createTime; // 大文本字段 @Lob private String description; // 关联关系映射（一对多） @OneToMany(mappedBy = "user") private List<Order> orders; ``` #### 4. **自定义转换器（复杂映射）** ```java @Converter(autoApply = true) public class BooleanConverter implements AttributeConverter<Boolean, String> { @Override public String convertToDatabaseColumn(Boolean value) { return value ? "Y" : "N"; } @Override public Boolean convertToEntityAttribute(String dbData) { return "Y".equals(dbData); } } // 实体类中使用 @Convert(converter = BooleanConverter.class) private Boolean isActive; ``` #### 配置注意事项 1. 在 `persistence.xml` 或 Spring Boot 的 `application.properties` 中配置数据源： ```properties spring.datasource.url=jdbc:mysql://localhost:3306/db spring.datasource.username=root spring.datasource.password=123456 spring.jpa.hibernate.ddl-auto=update ``` 2. 添加依赖（Maven 示例）： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> ``` > **最佳实践**： > - 优先使用默认的驼峰命名映射，减少冗余注解 > - 复杂字段（如枚举、JSON）通过自定义转换器实现 > - 关联关系使用 `@OneToMany`/`@ManyToOne` 避免 N+1 查询问题 > - 敏感字段用 `@Transient` 排除持久化[^2][^3]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

日出东方一点红

地址：jackzero.eth

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值