精华内容
下载资源
问答
  • mybatis动态增删改查

    2018-07-23 14:28:55
    原来使用sql时也都只是DML(Data Manipulation Language 数据操控语言...项目需求,根据前台传来的表名,字段,数据,进行动态的创建表格,实现对表格的增删改查操作。 首先创建一个实体类,用来封装操作表的数据...

          原来使用sql时也都只是DML(Data Manipulation Language 数据操控语言)的,对于DDL(Data Definition Language 数据定义语言)的操作比较少涉及,最近项目中恰巧需要进行DDL操作,进行简单的记录。项目需求,根据前台传来的表名,字段,数据,进行动态的创建表格,实现对表格的增删改查操作。

        首先创建一个实体类,用来封装操作表的数据。

    /**
     * 
     * @Description :动态操作表变量
     * @author Bush罗
     * @date 2018年7月19日
     *
     */
    public class OperateTable {
    	//表名
    	private String tableName;
    	//用于添加字段使用
    	private String wordSegment;
    	//用于创建数据库时使用,存放所有需要的字段
    	private List<String> listWord;
    	//字段所表示的中文意思,需要从前台传过来
    	private List<String> listWordMean;
    	//用于删除数据使用的id
    	private Integer id;
    	//表示一行数据,用户填写的一行数据
    	private List<String> listData;
    	//返回该数据库的所有表明
    	private List<String> listTableName;
    	//存放字段和数据
    	private Map<String,String> mapWordData;

    dao层接口

    public interface OperateTableService {
    	// 创建表
    	void createTable(OperateTable operateTable);
    
    	// 插入数据
    	void insertTable(OperateTable operateTable);
    
    	// 查找所有表名
    	List<TableName> findAllTableName();
    
    	// 更新数据库
    	void updateTable(@Param("content") Map<String, String> mapWordData);
    
    	// 更新数据库
    	void updateTable1(OperateTable operateTable);
    
    	// 动态删除数据
    	void deleteById(OperateTable operateTable);
    
    	// 动态为表添加字段
    	void addColumn(OperateTable operateTable);
    }

    最重要的动态sql语句,也是mybatis最大的优点,灵活

    <?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="com.smxy.lq.dao.OperateTableMapper">
    	<!--创建一个以id为主键的自增表 -->
    	<!-- 1.ddl使用update标签 -->
    	<!-- 2.ddl使用${}取值 -->
    	<!-- 3.动态列实际上只是普通的foreach, 常见问题是使用#{}取值造成语法错误 -->
    	<update id="createTable" parameterType="com.smxy.lq.pojo.OperateTable">
    		create table ${tableName} (
    		id int(100) NOT NULL PRIMARY KEY
    		AUTO_INCREMENT,
    		<foreach collection="listWord" item="word" separator=",">
    			${word}
    			varchar(255)
    		</foreach>
    		) ENGINE=InnoDB DEFAULT CHARSET=utf8
    	</update>
    	<insert id="insertTable" parameterType="com.smxy.office.pojo.OperateTable">
    		<!-- 将插入数据的主键返回,返回到对象中 SELECT LAST_INSERT_ID():得到刚insert进去记录的主键值,只适用与自增主键 
    			keyProperty:将查询到主键值设置到parameterType指定的对象的哪个属性 order:SELECT LAST_INSERT_ID()执行顺序,相对于insert语句来说它的执行顺序 
    			resultType:指定SELECT LAST_INSERT_ID()的结果类型 -->
    		<selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
    			SELECT
    			LAST_INSERT_ID()
    		</selectKey>
    		insert into
    		${tableName}
    		<trim prefix="(" suffix=")" suffixOverrides=",">
    			<foreach collection="mapWordData.keys" item="key" open=""
    				close="" separator=",">
    				${key}
    			</foreach>
    		</trim>
    		<trim prefix="values (" suffix=")" suffixOverrides=",">
    			<foreach collection="mapWordData.values" item="value"
    				separator=",">
    				#{value}
    			</foreach>
    		</trim>
    	</insert>
    	<!--查找所有数据库的表的名字 -->
    	<select id="findAllTableName" resultType="com.smxy.lq.pojo.TableName">
    		select
    		table_name
    		FROM
    		information_schema.tables
    		WHERE table_schema = 'market'
    		AND table_type =
    		'base table'
    		AND TABLE_NAME LIKE "office_%"
    	</select>
    	<!--动态更新数据库 -->
    	<update id="updateTable" parameterType="java.util.Map">
    		update office_1 SET
    		<foreach collection="content.keys" item="key" open="" close=""
    			separator=",">
    			${key} = #{content[${key}]}
    		</foreach>
    		where id = 1
    	</update>
    	<!-- 动态更新数据库 -->
    	<update id="updateTable1" parameterType="com.smxy.office.pojo.OperateTable">
    		update ${tableName}
    		<set>
    			<foreach item="value" index="key" collection="mapWordData.entrySet()"
    				open="" close="" separator=",">
    				${key}=#{value}
    			</foreach>
    		</set>
    		where id = #{id}
    	</update>
    	<!--动态删除数据 -->
    	<delete id="deleteById" parameterType="com.smxy.lq.pojo.OperateTable">
    		delete from ${tableName}
    		where id = #{id}
    	</delete>
    	<!--动态为表增加字段  -->
    	<update id="addColumn" parameterType="com.smxy.lq.pojo.OperateTable">
    		alter table ${tableName} add column ${wordSegment} varchar(255);
    	</update>
    </mapper>
    

    Controller测试用例

    /**
     * 
     * @Description :动态操作数据库案例
     * @author Bush罗
     * @date 2018年7月20日
     *
     */
    @Controller
    public class OperateTableController {
    	
    	@Autowired
    	private OperateTableService operateTableService;
    
    	@ResponseBody
    	@RequestMapping("/creat")
    	public String creat() {
    		System.out.println("创建");
    		OperateTable operateTable = new OperateTable();
    		operateTable.setTableName("office_1");
    		List<String> list = new LinkedList<String>();
    		list.add("of_1");
    		list.add("of_2");
    		list.add("of_3");
    		operateTable.setListWord(list);
    		operateTableService.createTable(operateTable);
    		return "创建成功";
    	}
    	@ResponseBody
    	@RequestMapping("/insertTable")
    	public String insertTable() {
    		System.out.println("插入");
    		OperateTable operateTable = new OperateTable();
    		operateTable.setTableName("office_1");
    		Map<String,String> mapWordData=new HashMap<String,String>();
    		mapWordData.put("username", "小红");
    		mapWordData.put("sex", "男");
    		mapWordData.put("phonenumber", "123456789");
    		mapWordData.put("teacherid", "500");
    		operateTable.setMapWordData(mapWordData);
    		operateTableService.insertTable(operateTable);
    		return "success";
    	}
    	
    	@ResponseBody
    	@RequestMapping("/updateTable")
    	public String updateTable() {
    		System.out.println("更新");
    		OperateTable operateTable = new OperateTable();
    		operateTable.setTableName("office_1");
    		Map<String,String> mapWordData=new HashMap<String,String>();
    		mapWordData.put("of_1", "小红");
    		mapWordData.put("of_2", "明");
    		mapWordData.put("of_3", "500");
    		operateTable.setMapWordData(mapWordData);
    		System.out.println(operateTable.toString());
    		operateTableService.updateTable(mapWordData);
    		return "更新成功";
    	}
    	@ResponseBody
    	@RequestMapping("/updateTable1")
    	public String updateTable1() {
    		System.out.println("更新1");
    		OperateTable operateTable = new OperateTable();
    		operateTable.setTableName("office_1");
    		Map<String,String> mapWordData=new HashMap<String,String>();
    		mapWordData.put("of_1", "6红");
    		mapWordData.put("of_2", null);
    		mapWordData.put("of_3", "小芳");
    		operateTable.setMapWordData(mapWordData);
    		operateTable.setId(3);
    		operateTableService.updateTable1(operateTable);
    		return "更新成功1";
    	}
    	@ResponseBody
    	@RequestMapping("delete")
    	public String delete(){
    		System.out.println("删除");
    		OperateTable operateTable = new OperateTable();
    		operateTable.setTableName("office_1");
    		operateTable.setId(3);
    		operateTableService.deleteById(operateTable);
    		return "删除成功";
    	}
    	@ResponseBody
    	@RequestMapping("addcolumn")
    	public String addcolumn(){
    		System.out.println("添加字段");
    		OperateTable operateTable = new OperateTable();
    		operateTable.setTableName("office_1");
    		operateTable.setWordSegment("of_4");
    		operateTableService.deleteById(operateTable);
    		return "添加成功";
    	}
    	
    
    }
    

     

    展开全文
  • 一.Mybatis动态增删改查 <!--先创建一个实体类,然后创建一个配置文件,以及一个测试类 --> <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//...

    一.Mybatis动态增删改查

    <!--先创建一个实体类,然后创建一个配置文件,以及一个测试类 -->
    <?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="com.hlp.dao.UsersDao">
        <select id="selectAll" resultType="Users">
            select * from users;
        </select>
        <!--动态添加-->
        <sql id="us">
          <trim suffixOverrides=",">
            <if test="uname!=null">
               uname,
            </if>
          </trim>
        </sql>
        <sql id="value">
    <trim suffixOverrides=",">
            <if test="uname!=null">
                #{uname},
            </if>
    </trim>
        </sql>
        <insert id="addUsers" parameterType="Users">
            insert into users(<include refid="us"></include>)values(<include refid="value"></include>);
        </insert>
        <!--动态条件查询-->
        <select id="findUsersByColumn" parameterType="Users" resultType="Users">
            select * from users
            <where>
                <if test="uid!=null">
                    and uid=#{uid}
                </if>
                <if test="uname!=null">
                    and uname like concat('%',#{uname},'%');
                </if>
            </where>
        </select>
        <!--动态批量删除-->
        <delete id="deleteUsers" parameterType="map">
            delete from users
            <where>
                    uid in 
                    <foreach collection="array" open="(" close=")" item="arr"  separator=",">
                        #{arr}
                    </foreach>
            </where>
        </delete>
        <!--动态修改-->
        <update id="updateUsers" parameterType="map">
            update users
            <set>
                <if test="uname!=null">
                    uname=#{uname},
                </if>
            </set>
            <where>
                uid=#{uid}
            </where>
        </update>
    
    </mapper>
    

    测试动态增删改查

    //测试动态剩下的自行写(这里的UserDao是接口用于实现类的映射文件中的方法)
     UsersDao ud=session.getMapper(UsersDao.class);
         
           Users users=new Users();
           users.setUname("周曦");
           ud.addUsers(users);
    

    二.Mybatis纯注解开发的基本增删改查(不再需要实体类的映射文件只需dao类(mapper类相当于实体类映射的实现(接口)))

    package com.hlp.mapper;
    
    import com.hlp.entity.Student;
    import org.apache.ibatis.annotations.Delete;
    import org.apache.ibatis.annotations.Insert;
    import org.apache.ibatis.annotations.Select;
    import org.apache.ibatis.annotations.Update;
    
    import java.util.List;
    
    public interface StudentMapper {
         //查询所有学生
        @Select("select * from student")
        public List<Student> findAllStudent();
        //添加学生
        @Insert("insert into student values(null,#{sname},#{sex},#{age})")
        public void addStudent(Student student);
        //删除学生
        @Delete("delete from student where sid=#{sid}")
        public void deleteStudent(int sid);
        //根据id查询学生
        @Select("select * from student where sid=#{sid}")
        public Student selectStudentById(int sid);
        //修改学生
        @Update("update student set sname=#{sname},sex=#{sex},age=#{age} where sid=#{sid}")
        public void updateStudentById(Student student);
    }
    
    

    调用纯注解增删改查

    package com.hlp.test;
    
    import com.hlp.entity.Student;
    import com.hlp.mapper.StudentMapper;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    
    import java.util.List;
    
    public class Alltest {
        private SqlSession session;
        @Before
        public void before(){
            SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(getClass().getClassLoader().getResourceAsStream("Mybatis-config.xml"));
            session = factory.openSession();
        }
        @Test
        public void test(){
          StudentMapper mapper=session.getMapper(StudentMapper.class);
          /*    List<Student> list=mapper.findAllStudent();
            for (Student student : list) {
                System.out.println(student);
            }*/
            //动解增加
          /*Student st=new Student("周一","男",18);
          mapper.addStudent(st);*/
          //动态注解删除
         /* mapper.deleteStudent(16);*/
         //动态注解修改
            Student st= mapper.selectStudentById(13);
            st.setSname("周一");
            st.setSex("男");
           st.setAge(18);
           //动态注解查询
            mapper.updateStudentById(st);
        }
        @After
        public void after(){
            session.commit();
            session.close();
        }
    }
    

    三.Mybatis纯注解开发一对一,一对多,多对多
    1.一对一例如用户与身份证

    //我们首先在用户的映射实现类当中查询所有的用户
    //one=@One(select = "com.hlp.mapper.CardMapper.selectCardByUid")这是与他一对一的身份证映射
    //实现类当中的方法,,column 关联列,property 与之对应的属性之后不再做解释
     @Select("select * from users")
        @Results({
                @Result(property = "card",column = "uid",one=@One(select = "com.hlp.mapper.CardMapper.selectCardByUid"))
        })
    //根据用户查询身份证(在身份证的映射实现类中)
     @Select("select * from card where uid=#{uid}")
        public Card selectCardByUid(int uid);
        @Select("select * from Card")
        //我写的是查询用户以及相对应的身份证,另一半自行根据以上写
    

    2.一对多(省份对城市)

    //在省份的映射实体类
      @Select("select * from Province")
        @Results({
                @Result(property = "cities",column = "pid",many = @Many(select = "com.hlp.mapper.CityMapper.selectCityByPid"))
        })
        public List<Province> selectAllProvince();
        //在城市的映射实体类
         @Select("select * from city where pid=#{pid}")
        public List<City> selectCityByPid(int pid);
        //注意城市对省份是一对一关系,有关这个请看第一点
    

    3.多对多(老师对学生)

    //在老师的映射实现类中
     @Select("select * from teacher")
        @Results({
                @Result(property = "students",column = "tid",many = @Many(select = "com.hlp.mapper.StudentsMapper.selectStudentsByTid"))
        })
        public List<Teacher> selectAllTeacher();
        //在学生的映射实现类中(通过与第三方表联查来查询老师对应的学生)
          @Select("select s.*,stu.* from students s,stu_tea stu where s.sid=stu.sid and stu.tid=#{tid}")
        public List<Students> selectStudentsByTid(int tid);
        //另一半自行根据以上自行写
        
    
    展开全文
  • mybatis可以根据已有的数据库表进行相应的代码生成,为项目的创建书写提供便利,会根据数据库表字段创建对应的实体类,与通用mapper接口以及对应的实现配置,额外提供了对于单表操作动态拼写的相应配置. 2、逆向工程...

    Mybatis 逆向工程

    1、概念

    mybatis可以根据已有的数据库表进行相应的代码生成,为项目的创建书写提供便利,会根据数据库表字段创建对应的实体类,与通用mapper接口以及对应的实现配置,额外提供了对于单表操作动态拼写的相应配置.

    2、逆向工程创建

    (1)创建项目

    (2)导入逆向工程jar包与mysql连接jar包

    所需资源链接:https://pan.baidu.com/s/1OsSVCfRMnWcFzRgJC4J54A
    提取码:3kem

    (3)编写生成配置文件(gen.xml)

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE generatorConfiguration
            PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
            "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
    
    <generatorConfiguration>
        <context id="testTables" targetRuntime="MyBatis3">
            <commentGenerator>
                <!-- 是否去除自动生成的注释 true:是 : false:否 -->
                <property name="suppressAllComments" value="true" />
            </commentGenerator>
            <!--数据库连接的信息:驱动类、连接地址、用户名、密码 -->
            <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                            connectionURL="jdbc:mysql://localhost:3306/mydb" userId="root"
                            password="root">
            </jdbcConnection>
            <!-- targetProject:生成PO类的位置 -->
            <javaModelGenerator targetPackage="com.yunhe.pojo"
                                targetProject="./src">
                <!-- enableSubPackages:是否让schema作为包的后缀 -->
                <property name="enableSubPackages" value="false" />
                <!-- 从数据库返回的值被清理前后的空格 -->
                <property name="trimStrings" value="true" />
                
            </javaModelGenerator>
            <!-- targetProject:mapper映射文件生成的位置 -->
            <sqlMapGenerator targetPackage="com.yunhe.mapper"
                             targetProject="./src">
                <!-- enableSubPackages:是否让schema作为包的后缀 -->
                <property name="enableSubPackages" value="false" />
            </sqlMapGenerator>
            <!-- targetPackage:mapper接口生成的位置 -->
            <javaClientGenerator type="XMLMAPPER"
                                 targetPackage="com.yunhe.mapper"
                                 targetProject="./src">
                <!-- enableSubPackages:是否让schema作为包的后缀 -->
                <property name="enableSubPackages" value="false" />
            </javaClientGenerator>
            <!-- 指定数据库表 -->
            <table tableName="author"></table>
            <table tableName="commodity"></table>
            <table tableName="order"></table>
            <table tableName="role"></table>
            <table tableName="user"></table>
        </context>
    </generatorConfiguration>
    
    

    (4)创建类读取配置文件生成代码(Test类)

    import org.mybatis.generator.api.MyBatisGenerator;
    import org.mybatis.generator.config.Configuration;
    import org.mybatis.generator.config.xml.ConfigurationParser;
    import org.mybatis.generator.internal.DefaultShellCallback;
    
    import java.io.File;
    import java.io.InputStream;
    import java.util.ArrayList;
    import java.util.List;
    
    public class Test {
        public static void main(String[] args) throws Exception{
            List<String> warnings = new ArrayList<String>();
            boolean overwrite = true;
            //加载逆向生成配置文件信息
            //加载src下的配置文件
            InputStream resourceAsStream = Test.class.getClassLoader().getResourceAsStream("gen.xml");
            ConfigurationParser cp = new ConfigurationParser(warnings);
            //如果加载绝对路径下的配置文件可以将resourceAsStream改为new File(url);
            Configuration config = cp.parseConfiguration(resourceAsStream);
            DefaultShellCallback callback = new DefaultShellCallback(overwrite);
            MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
            myBatisGenerator.generate(null);
        }
    }
    

    3 生成代码基本使用

    mybatis生成实体类只会生成对应的属性以及gettter与setter方法,构造方法、序列化、toString方法根据实际使用添加

    3.1 添加

    SqlSessionFactory sqlSessionFactory = MyBatisUtil.getSqlSessionFactory();
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //添加
    User user=new User("新增","1234576");
    //insert into user (uid, uusername, upassword ) values (?, ?, ? )
    mapper.insert(user);
    
    //insert into user ( uusername, upassword ) values ( ?, ? ) 
    mapper.insertSelective(user);
    
    DEBUG [main] - ==>  Preparing: insert into user (uid, uusername, upassword ) values (?, ?, ? ) 
    DEBUG [main] - ==> Parameters: null, 新增(String), 1234576(String)
    DEBUG [main] - <==    Updates: 1
    DEBUG [main] - ==>  Preparing: insert into user ( uusername, upassword ) values ( ?, ? ) 
    DEBUG [main] - ==> Parameters: 新增(String), 1234576(String)
    DEBUG [main] - <==    Updates: 1
    

    3.2 修改

    SqlSessionFactory sqlSessionFactory = MyBatisUtil.getSqlSessionFactory();
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //修改
    User user=new User(8,null,"1234576");
    //update user set uusername = ?, upassword = ? where uid = ? 
    mapper.updateByPrimaryKey(user);
    
    //update user SET upassword = ? where uid = ? 
    mapper.updateByPrimaryKeySelective(user);
    
    DEBUG [main] - ==>  Preparing: update user set uusername = ?, upassword = ? where uid = ? 
    DEBUG [main] - ==> Parameters: null, 1234576(String), 8(Integer)
    DEBUG [main] - <==    Updates: 1
    DEBUG [main] - ==>  Preparing: update user SET upassword = ? where uid = ? 
    DEBUG [main] - ==> Parameters: 1234576(String), 8(Integer)
    DEBUG [main] - <==    Updates: 1
    

    3.3 删除

    SqlSessionFactory sqlSessionFactory = MyBatisUtil.getSqlSessionFactory();
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
    //删除
    //delete from user where uid = ?
    mapper.deleteByPrimaryKey(8);
    
    DEBUG [main] - ==>  Preparing: delete from user where uid = ? 
    DEBUG [main] - ==> Parameters: 8(Integer)
    DEBUG [main] - <==    Updates: 1
    

    3.4 查询

    SqlSessionFactory sqlSessionFactory = MyBatisUtil.getSqlSessionFactory();
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //查询
    //select uid, uusername, upassword from user where uid = ? 
    User user = mapper.selectByPrimaryKey(1);
    System.out.println(user);
    
    DEBUG [main] - ==>  Preparing: select uid, uusername, upassword from user where uid = ? 
    DEBUG [main] - ==> Parameters: 1(Integer)
    DEBUG [main] - <==      Total: 1
    User{uid=1, uusername='zhangsan', upassword='sadsadsad'}
    
    展开全文
  • 实体类 package com.phone.entity; import lombok.Data; import lombok.ToString; @Data public class MyDatasource { private String driverClassName; private String db; private String username; ...

    实体类

    package com.phone.entity;
    
    import lombok.Data;
    import lombok.ToString;
    
    @Data
    public class MyDatasource {
    
    	private String driverClassName;
    	
    	private String db;
    	
    	private String username;
    	
    	private String password;
    	
    	private String ip;
    	
    	private String port;
    	
    	private String sql;
    	
    	private String dbType;
    	
    	private String url;
    	
    	private org.springframework.jdbc.datasource.DriverManagerDataSource driverManagerDataSource;
    
    	@Override
    	public String toString() {
    		return "MyDatasource [driverClassName=" + driverClassName + ", db=" + db + ", username=" + username
    				+ ", password=" + password + ", ip=" + ip + ", port=" + port + ", sql=" + sql + ", dbType=" + dbType
    				+ ", url=" + url + ", driverManagerDataSource=" + driverManagerDataSource + "]";
    	}
    }
    

    缓存机制

    package com.phone.jdbc;
    
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.jdbc.datasource.DriverManagerDataSource;
    import org.springframework.stereotype.Component;
    
    import com.phone.entity.MyDatasource;
    
    @Aspect
    @Component
    public class AdviceTest {
    	private static Map<String,DriverManagerDataSource> map=new HashMap<>();
    	
    	// 表达式需要根据实际情况修改
    	//@Around("execution(* com.phone.jdbc.*.testConnection*(..))")
    	@Around("execution(* com.phone.jdbc.*.*(..))")
        public Object process(ProceedingJoinPoint point) throws Throwable {
    		System.out.println(map);
            System.out.println("@Around:执行目标方法之前...");
            //访问目标方法的参数:
            Object[] args = point.getArgs();
            if (args != null && args.length > 0 && args[0].getClass() == MyDatasource.class) {
            	MyDatasource myDatasource= (MyDatasource) args[0];
            	String url = "jdbc:DBTYPE://IP:PORT/DB?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT";
        		url=url.replace("DBTYPE", myDatasource.getDbType()).replace("IP", myDatasource.getIp()).replace("PORT", myDatasource.getPort()).replace("DB", myDatasource.getDb());
        		myDatasource.setUrl(url);
        		DriverManagerDataSource myDatasource2 = map.get(url);
            	if(myDatasource2==null) {
            		System.out.println("没用缓存");
            			DriverManagerDataSource dataSource=new DriverManagerDataSource();        		
            		dataSource.setUsername(myDatasource.getUsername());
            		dataSource.setPassword(myDatasource.getPassword());
            		dataSource.setDriverClassName(myDatasource.getDriverClassName());
            		dataSource.setUrl(url);
            		myDatasource.setDriverManagerDataSource(dataSource);
            		args[0]=myDatasource;
                   	Object proceed = point.proceed(args);
                   	if(proceed !=null) {
                   		map.put(url, dataSource);
                   	}
                   	return (List<Map<String,Object>>)proceed;
                    //return Collections.EMPTY_LIST; 
            	}else {
            		System.out.println("使用缓存");
            		myDatasource.setDriverManagerDataSource(myDatasource2);
            		Object proceed = point.proceed(args);
            		return (List<Map<String,Object>>)proceed;
                    //return Collections.EMPTY_LIST; 
            	}
            }
            //用改变后的参数执行目标方法
            System.out.println("@Around:执行目标方法之后...");
            System.out.println("@Around:被织入的目标对象为:" + point.getTarget());
    		return args;
           
        }
    }
    

    查询的一个demo

    package com.phone.jdbc;
    
    import java.util.Collections;
    import java.util.List;
    import java.util.Map;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.phone.entity.MyDatasource;
    
    @RestController
    public class QueryDa {
    
    	/**
    	 * 动态使用任意数据库查询数据
    	 * @param myDatasource
    	 */
    	@PostMapping("testConnection")
    	public List<Map<String,Object>> testConnection(@RequestBody MyDatasource myDatasource) {
    		JdbcTemplate jdbcTemplate=new JdbcTemplate();
    		jdbcTemplate.setDataSource(myDatasource.getDriverManagerDataSource());
    		String sql=myDatasource.getSql();
    		List<Map<String,Object>> queryForList = jdbcTemplate.queryForList(sql);
    		if(queryForList==null) {
    			return Collections.EMPTY_LIST;
    		}
    		for (Map<String, Object> map : queryForList) {
    			System.out.println("-------------------");
    			for (String key : map.keySet()) {
    				Object object = map.get(key);
    				System.out.println("key:"+key+"|value:"+object);
    			}
    		}
    		return queryForList;
    	}
    	
    	
    	
    }
    
    展开全文
  • 1、动态sql插入及将主键task_id注入到实体类taskId属性中 @Insert({"<script>"," insert into "+ TableUtils.CLOUD_TASK_TABLE+ "<trim prefix=\"(\" suffix=\")\" suffixOverrides=\",\" >" + ...
  • (1)建立dao包、实体类entity、和测试类test (2)建立一个resource文件夹 (3)WEB-INF中lib包放入三个jar包文件 dao包中有2个代码文件、一个是java接口文件、一个是xml文件. 注意:名字要相同. 下图是dao包中的...
  • ActiveRecord模式进行增删改查 1、ActiveRecord 模式介绍 ActiveRecord(活动记录),是一种领域模型模式,特点是一个模型对应关系型数据库中的一个表,而模型的一个实例对应表中的一行记录。 ActiveRecord ...
  • 这些实体类与数据库表建立的映射关系,提供通用的CRUD操作API,能够自动生成预先SQL语句并执行,使用者可以通过针对对象的思维方式来轻松完成增删改查的操作。 它具有以下特点: 开箱即用 EasyJpa上手简单,只要有...
  • User 用户类 ...@Entity // 该注解声明一个实体类,与数据库中的表对应 public class User { @Id // 表明主键id @GeneratedValue // 主键的生成策略(看最下方注释具体说明) private Long us
  • 3.创建实体类(User)-domian 4.创建数据库 5.配置xml文件(mybatis-config) .复制粘贴mybatis.pdf中的内容 .进行xml catalog配置,让其能够有提示 1.复制config那段,然后进行xml catalog 2.选择web-inf下的...
  • 文章目录4.Servlet实战4.1 需求概述4.2 具体实现4.2.1 项目初始化1) 整理数据库2) 整理表3) 创建项目4) 创建各类包在src下4.2.2 entity层-用户数据实体类 UserInfo.java4.2.3 utils层-数据库连接工具类 JdbcUtil....
  • 文章目录2.JSP实战优化:使用分层技术处理业务逻辑2.1 ... 新项目导包,工具类,实体类编写2.5.2 整理DAO层需求2.5.3 整理Service层需求2.5.4 页面控制器整理1) 查询全部的控制器2) 按ID查询的控制器3) 添加的控制器4) ...
  •   Mybatis 开发也可以...文章目录一、Mybatis 的常用注解说明二、Mybatis 注解开发需要说明的问题三、使用 Mybatis 注解实现基本 CRUD3.1 编写实体类3.2 一、Mybatis 的常用注解说明 @Insert:实现新增 @Update:实现
  • 对JDBC的一个薄封装工具,提供基本的增删改改查操作; 此库以追求简单稳定高效为目标,不支持查询结果实体映射,返回对象类型统一为 , 提供了一个简单的实体相互转换,若需要复杂映射,可自行通过来实现。 Maven...
  • Mybatis 实例 config包 为Mybatis的配置文件,连接数据库配置,加载mappers等 ... test包 利用Junit测试,MybatisTest.java 为简单的增删改查,2 为多行查询,3为事务,4为关联查询…. log4j.pro
  • 因为这个表中的字段是动态的 ,用户可以自定义创建表 ,现在我想在这个表创建完成后对它进行操作, 就是"增删改查"之的 ,不用SQL语句还有什么方法可以做出来吗 ? 先谢谢各位高手的指点了 !
  • 有了逆向工程,单表的增删改查以及相关的实体类,还有属性注释都不用自己写了,都可以自动化生成,只需如下三步即可 逆向工程的优点是:自动化生成实体类和对应的增删改查,效率相对于之前个人开发时一个个写增删改...
  • 业务逻辑类:具体业务逻辑代码(增删改查)。 代理逻辑接口类:JDK提供的InvocationHandler接口。 代理逻辑类:具体业务逻辑代码(修改目标方法)。 代理生成类:JDK提供的Proxy类。 实体类User publ...
  • 图片(比如填报一个产品,这个产品有很多属性,里面有这种动态增删改查操作,应该怎么操作),像这种的还有传视频还有图片什么的 思路: 后端:是再创建一个表,专门存这种动态的数据(数据库表这样,里面存一...
  • Spring AOP动态代理例子

    千次阅读 2017-10-21 00:46:58
    对Oracle数据库的部门表进行增删改查: 话不多说; 1.实体类可以不写.hbm.xml文件直接写注解方式: package com.jadeon.entity; import java.io.Serializable; import javax.persistence.Column; import javax...
  • 文章目录1、综述2、实现Mapper动态代理2.1 映射文件的namespace属性值2.2 Dao接口方法名2.3 Dao对象的获取2.4 删除Dao实现类3、测试案例3.1 创建测试数据表3.2 创建实体类3.3 创建Dao文件3.4 创建SQL映射文件3.5 ...
  • ArrayList数组保存数据,完成增删改查的操作。对Student实体类创建,包含8个字段:学号、密码、姓名、性别、学院、爱好、自我介绍、照片。表单使用密码、单选、复选、列表、文件域等控件学生信息实现分页浏览。这是...
  • 如果我们单纯只想每一次进行一次增删改查的话,获取连接在用完之后会自动提交。 但是如果我们在业务层要进行组合操作,比如我们要进行转账操作:涉及到持久层的操作有(查询、更新) eg:A给B转账 具体操作逻辑:...
  • 为我们动态生成常用增删改查操作的SQL语句,修改实体类自动修改Mapper的SQL语句 代码官方发布地址 官网(如下图显示) 前置知识 具备Spring/Mybatis 知识 创建实体类需要注意的点: 1.考虑到基本数据类型在...
  • Mybatis的动态代理

    2020-02-10 11:11:21
    使用mapper代理方式对数据进行--使用了接口--进行多个参数的传递。 注意事项: (1)xml文件(mapper)的名称必须与接口的名称相同; (2)select、update、insert中的id的名称必须与接口中方法的...
  • 通用Mapper是一款用于单表增删改查的Mybatis插件,开发人员可以省去编写sql语句和在DAO层编写任何方法,毫不客气的说,使用这个通用Mapper甚至能改变你对Mybatis单表基础操作不方便的想法,使用它你能简单的使用单表的...
  • Mybatis 学习

    2018-10-30 14:58:00
    阅读前,先看一遍官方的...Entity实体类就是数据库中对应的类,接口是让我们操作数据库数据的类,就是增删改查的接口类,而mapper.xml 文件是我们动态编写SQL 的地方。直接看例子,比较直观。 实体类 1 public clas...
  • Mybaits映射要点总结

    2018-02-27 11:13:34
    增删改查的普通映射,参数类似于el表达式 resultMap对应实体类 高级映射中ResultMap: constructor 用于构造方法 result 用于普通字段 association 用于复杂类 collection 用于复杂类集合 discriminator 根据不同...

空空如也

空空如也

1 2 3 4
收藏数 71
精华内容 28
关键字:

动态实体类增删改查