//1. 导入驱动jar包
//2.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
//4.定义sql语句
String sql = "update account set balance = 500 where id = 1";
//5.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
//6.执行sql
int count = stmt.executeUpdate(sql);
//7.处理结果
System.out.println(count);
//8.释放资源
stmt.close();
conn.close();

1. DriverManager：驱动管理对象
	* 功能：
		1. 注册驱动：告诉程序该使用哪一个数据库驱动jar
			static void registerDriver(Driver driver) :注册与给定的驱动程序 DriverManager 。 
			写代码使用：  Class.forName("com.mysql.jdbc.Driver");
			通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块
			 static {
			        try {
			            java.sql.DriverManager.registerDriver(new Driver());
			        } catch (SQLException E) {
			            throw new RuntimeException("Can't register driver!");
			        }
				}

			注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。
		2. 获取数据库连接：
			* 方法：static Connection getConnection(String url, String user, String password) 
			* 参数：
				* url：指定连接的路径
					* 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
					* 例子：jdbc:mysql://localhost:3306/db3
					* 细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
				* user：用户名
				* password：密码 
				
2. Connection：数据库连接对象
	1. 功能：
		1. 获取执行sql 的对象
			* Statement createStatement()
			* PreparedStatement prepareStatement(String sql)  
		2. 管理事务：
			* 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
			* 提交事务：commit() 
			* 回滚事务：rollback() 
3. Statement：执行sql的对象
	1. 执行sql
		1. boolean execute(String sql) ：可以执行任意的sql 了解 
		2. int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句
			* 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功，反之，则失败。
		3. ResultSet executeQuery(String sql)  ：执行DQL（select)语句
	2. 练习：
		1. account表 添加一条记录
		2. account表 修改记录
		3. account表 删除一条记录

		代码：
			Statement stmt = null;
	        Connection conn = null;
	        try {
	            //1. 注册驱动
	            Class.forName("com.mysql.jdbc.Driver");
	            //2. 定义sql
	            String sql = "insert into account values(null,'王五',3000)";
	            //3.获取Connection对象
	            conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
	            //4.获取执行sql的对象 Statement
	            stmt = conn.createStatement();
	            //5.执行sql
	            int count = stmt.executeUpdate(sql);//影响的行数
	            //6.处理结果
	            System.out.println(count);
	            if(count > 0){
	                System.out.println("添加成功！");
	            }else{
	                System.out.println("添加失败！");
	            }
	
	        } catch (ClassNotFoundException e) {
	            e.printStackTrace();
	        } catch (SQLException e) {
	            e.printStackTrace();
	        }finally {
	            //stmt.close();
	            //7. 释放资源
	            //避免空指针异常
	            if(stmt != null){
	                try {
	                    stmt.close();
	                } catch (SQLException e) {
	                    e.printStackTrace();
	                }
	            }
	
	            if(conn != null){
	                try {
	                    conn.close();
	                } catch (SQLException e) {
	                    e.printStackTrace();
	                }
	            }
	        }
		
4. ResultSet：结果集对象,封装查询结果
	* boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true
	* getXxx(参数):获取数据
		* Xxx：代表数据类型   如： int getInt() ,	String getString()
		* 参数：
			1. int：代表列的编号,从1开始   如： getString(1)
			2. String：代表列名称。 如： getDouble("balance")
	
	* 注意：
		* 使用步骤：
			1. 游标向下移动一行
			2. 判断是否有数据
			3. 获取数据

		   //循环判断游标是否是最后一行末尾。
            while(rs.next()){
                //获取数据
                //6.2 获取数据
                int id = rs.getInt(1);
                String name = rs.getString("name");
                double balance = rs.getDouble(3);

                System.out.println(id + "---" + name + "---" + balance);
            }

	* 练习：
		* 定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
			1. 定义Emp类
			2. 定义方法 public List<Emp> findAll(){}
			3. 实现方法 select * from emp;
				
5. PreparedStatement：执行sql的对象
	1. SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
		1. 输入用户随便，输入密码：a' or 'a' = 'a
		2. sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a' 

	2. 解决sql注入问题：使用PreparedStatement对象来解决
	3. 预编译的SQL：参数使用?作为占位符
	4. 步骤：
		1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
		2. 注册驱动
		3. 获取数据库连接对象 Connection
		4. 定义sql
			* 注意：sql的参数使用？作为占位符。 如：select * from user where username = ? and password = ?;
		5. 获取执行sql语句的对象 PreparedStatement  Connection.prepareStatement(String sql) 
		6. 给？赋值：
			* 方法： setXxx(参数1,参数2)
				* 参数1：？的位置编号 从1 开始
				* 参数2：？的值
		7. 执行sql，接受返回结果，不需要传递sql语句
		8. 处理结果
		9. 释放资源

	5. 注意：后期都会使用PreparedStatement来完成增删改查的所有操作
		1. 可以防止SQL注入
		2. 效率更高

* 代码：
       
       public class JDBCUtils {

		    //1.定义成员变量 DataSource
		    private static DataSource ds ;
		
		    static{
		        try {
		            //1.加载配置文件
		            Properties pro = new Properties();
		            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
		            //2.获取DataSource
		            ds = DruidDataSourceFactory.createDataSource(pro);
		        } catch (IOException e) {
		            e.printStackTrace();
		        } catch (Exception e) {
		            e.printStackTrace();
		        }
		    }
		
		    /**
		     * 获取连接
		     */
		    public static Connection getConnection() throws SQLException {
		        return ds.getConnection();
		    }
		
		    /**
		     * 释放资源
		     */
		    public static void close(Statement stmt,Connection conn){
		       /* if(stmt != null){
		            try {
		                stmt.close();
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		
		        if(conn != null){
		            try {
		                conn.close();//归还连接
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }*/
		
		       close(null,stmt,conn);
		    }
		
		
		    public static void close(ResultSet rs , Statement stmt, Connection conn){
		
		
		        if(rs != null){
		            try {
		                rs.close();
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		
		
		        if(stmt != null){
		            try {
		                stmt.close();
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		
		        if(conn != null){
		            try {
		                conn.close();//归还连接
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		    }
		
		    /**
		     * 获取连接池方法
		     */
		
		    public static DataSource getDataSource(){
		        return  ds;
		    }
		
		}

@Configuration 
@EnableTransactionManagement 
public class SpringTxConfiguration { 
 //里面配置数据源，配置 JdbcTemplate,配置事务管理器。在之前的步骤已经写过了。 } 

/**
        * 一个经纪公司的要求:
        *       能做基本的表演和危险的表演
       */
       public interface IActor {
            /**
             * 基本演出
             * @param money
             */
            public void basicAct(float money);
            /**
             * 危险演出
             * @param money
             */
            public void dangerAct(float money);
       }

       /**
        * 一个演员
        */

---------------------------------------------

       //实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
       public class Actor implements IActor{

            public void basicAct(float money){
                System.out.println("拿到钱，开始基本的表演："+money);
            }

            public void dangerAct(float money){
                System.out.println("拿到钱，开始危险的表演："+money);
            }
       }

----------------------------------------------
       public class Client {

            public static void main(String[] args) {
                //一个剧组找演员：
                final Actor actor = new Actor();//直接

                /**
                 * 代理：
                 *  间接。
                 * 获取代理对象：
                 *  要求：
                 *   被代理类最少实现一个接口
                 * 创建的方式
                 *   Proxy.newProxyInstance(三个参数)
                 * 参数含义：
                 *  ClassLoader：和被代理对象使用相同的类加载器。.
                 *  Interfaces：和被代理对象具有相同的行为。实现相同的接口。.
                 *  InvocationHandler：如何代理。
                 *      策略模式：使用场景是：
                 *                   数据有了，目的明确。
                 *                   如何达成目标，就是策略。
                 *
                 */
                IActor proxyActor = (IActor) Proxy.newProxyInstance(
                                                 actor.getClass().getClassLoader(),
                                                 actor.getClass().getInterfaces(),
                                                 new InvocationHandler() {
                        /**
                         * 执行被代理对象的任何方法，都会经过该方法。
                         * 此方法有拦截的功能。
                         *
                         * 参数：
                         *  proxy：代理对象的引用。不一定每次都用得到
                         *  method：当前执行的方法对象
                         *  args：执行方法所需的参数
                         * 返回值：
                         *  当前执行方法的返回值
                         */
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
                            String name = method.getName();
                            Float money = (Float) args[0];
                            Object rtValue = null;
                            //每个经纪公司对不同演出收费不一样，此处开始判断
                            if("basicAct".equals(name)){
                                 //基本演出，没有 2000 不演
                                 if(money > 2000){
                                     //看上去剧组是给了 8000，实际到演员手里只有 4000
                                     //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
                                     rtValue = method.invoke(actor, money/2);
                                 }
                            }
                            if("dangerAct".equals(name)){
                                 //危险演出,没有 5000 不演
                                 if(money > 5000){
                                     //看上去剧组是给了 50000，实际到演员手里只有 25000
                                     //这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
                                     rtValue = method.invoke(actor, money/2);
                                 }
                            }
                            return rtValue;
                        }
                });
                //没有经纪公司的时候，直接找演员。
       //       actor.basicAct(1000f);
       //       actor.dangerAct(5000f);

                //剧组无法直接联系演员，而是由经纪公司找的演员
                proxyActor.basicAct(8000f);
                proxyActor.dangerAct(50000f);
            }
       }

       /**
        * 一个演员
       */
       public class Actor{//没有实现任何接口

            public void basicAct(float money){
                System.out.println("拿到钱，开始基本的表演："+money);
            }

            public void dangerAct(float money){
                System.out.println("拿到钱，开始危险的表演："+money);
            }
       }


-------------------------------------
       public class Client {
            /**
             * 基于子类的动态代理
             *  要求：
             *      被代理对象不能是最终类
             *  用到的类：
             *      Enhancer
             *  用到的方法：
             *      create(Class, Callback)
             *  方法的参数：
             *      Class：被代理对象的字节码
             *      Callback：如何代理
             * @param args
             */
            public static void  main(String[] args) {
                final Actor actor = new Actor();
                Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
                                     new MethodInterceptor() {
                    /**
                     * 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
   方法进行增强。
                     *
                     * 参数：
                     *  前三个和基于接口的动态代理是一样的。
                     *  MethodProxy：当前执行方法的代理对象。
                     * 返回值：
                     *  当前执行方法的返回值
                     */
                    @Override
                    public Object intercept(Object proxy, Method method, Object[] args,
   MethodProxy methodProxy) throws Throwable {
                        String name = method.getName();
                        Float money = (Float) args[0];
                        Object rtValue = null;
                        if("basicAct".equals(name)){
                            //基本演出
                            if(money > 2000){
                                 rtValue = method.invoke(actor, money/2);
                            }
                        }
                        if("dangerAct".equals(name)){
                            //危险演出
                            if(money > 5000){
                                 rtValue = method.invoke(actor, money/2);
                            }
                        }
                        return rtValue;
                    }
                });
                cglibActor.basicAct(10000);
                cglibActor.dangerAct(100000);
            }
       }
       

客户的业务层实现类
       /**
        * 账户的业务层实现类
        */
       public class AccountServiceImpl implements IAccountService {

            private IAccountDao accountDao;

            public void setAccountDao(IAccountDao accountDao) {
                this.accountDao = accountDao;
            }

            @Override
            public void saveAccount(Account account) throws SQLException {
                accountDao.save(account);
            }

            @Override
            public void updateAccount(Account account) throws SQLException{
                accountDao.update(account);
            }

            @Override
            public void deleteAccount(Integer accountId) throws SQLException{
                accountDao.delete(accountId);
            }

            @Override
            public Account findAccountById(Integer accountId) throws SQLException {
                return accountDao.findById(accountId);
            }

            @Override
            public List<Account> findAllAccount() throws SQLException{
                return accountDao.findAll();
            }
       }
       

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
     private IAccountDao accountDao = new AccountDaoImpl();


     @Override
     public void saveAccount(Account account) {
         try {
             TransactionManager.beginTransaction();
             accountDao.save(account);
             TransactionManager.commit();
         } catch (Exception e) {
             TransactionManager.rollback();
             e.printStackTrace();
         }finally {
             TransactionManager.release();
         }
     }

     @Override
     public void updateAccount(Account account) {
         try {
             TransactionManager.beginTransaction();
             accountDao.update(account);
             TransactionManager.commit();
         } catch (Exception e) {
             TransactionManager.rollback();
             e.printStackTrace();
         }finally {
             TransactionManager.release();
         }
     }

     @Override
     public void deleteAccount(Integer accountId) {
         try {
             TransactionManager.beginTransaction();
             accountDao.delete(accountId);
             TransactionManager.commit();
         } catch (Exception e) {
             TransactionManager.rollback();
             e.printStackTrace();
         }finally {
             TransactionManager.release();
         }
     }

     @Override
     public Account findAccountById(Integer accountId) {
         Account account = null;
         try {
             TransactionManager.beginTransaction();
             account = accountDao.findById(accountId);
             TransactionManager.commit();
             return account;
         } catch (Exception e) {
             TransactionManager.rollback();
             e.printStackTrace();
         }finally {
             TransactionManager.release();
         }
         return null;
     }

     @Override
     public List<Account> findAllAccount() {
         List<Account> accounts = null;
         try {
             TransactionManager.beginTransaction();
             accounts = accountDao.findAll();
             TransactionManager.commit();
             return accounts;
         } catch (Exception e) {
             TransactionManager.rollback();
             e.printStackTrace();
         }finally {
             TransactionManager.release();
         }
         return null;
     }

     @Override
     public void transfer(String sourceName, String targetName, Float money) {
         try {
             TransactionManager.beginTransaction();
             Account source = accountDao.findByName(sourceName);
             Account target = accountDao.findByName(targetName);
             source.setMoney(source.getMoney()-money);
             target.setMoney(target.getMoney()+money);
             accountDao.update(source);
             int i=1/0;
             accountDao.update(target);
             TransactionManager.commit();
         } catch (Exception e) {
             TransactionManager.rollback();
             e.printStackTrace();
         }finally {
             TransactionManager.release();
         }
     }
}

TransactionManager 类的代码：
/**
 * 事务控制类
 */
public class TransactionManager {

     //定义一个 DBAssit
     private static DBAssit dbAssit =  new DBAssit(C3P0Utils.getDataSource(),true);


     //开启事务
     public static void beginTransaction() {
         try {
             dbAssit.getCurrentConnection().setAutoCommit(false);
         } catch (SQLException e) {
             e.printStackTrace();
         }
     }

     //提交事务
     public static void commit() {
         try {
             dbAssit.getCurrentConnection().commit();
         } catch (SQLException e) {
             e.printStackTrace();
         }
     }

     //回滚事务

     public static void rollback() {
         try {
             dbAssit.getCurrentConnection().rollback();
         } catch (SQLException e) {
             e.printStackTrace();
         }
     }

     //释放资源
     public static void release() {
         try {
             dbAssit.releaseConnection();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
}

等吧这个代码写了再码上来~

/**
        * 事务控制类
        */
       public class TransactionManager {

            //定义一个 DBAssit
            private DBAssit dbAssit ;

            public void setDbAssit(DBAssit dbAssit) {
                this.dbAssit = dbAssit;
            }

            //开启事务
            public void beginTransaction() {
                try {
                    dbAssit.getCurrentConnection().setAutoCommit(false);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            //提交事务
            public void commit() {
                try {
                    dbAssit.getCurrentConnection().commit();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            //回滚事务
            public void rollback() {
                try {
                    dbAssit.getCurrentConnection().rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            //释放资源
            public void release() {
                try {
                    dbAssit.releaseConnection();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
       }

/**
        * 事务控制类
        */
       @Component("txManager")
       public class TransactionManager {
            //定义一个 DBAssit
            @Autowired
            private DBAssit dbAssit ;
        }

/**
        * 事务控制类
        */
       @Component("txManager")
       @Aspect//表明当前类是一个切面类
       public class TransactionManager {

            //定义一个 DBAssit
            @Autowired
            private DBAssit dbAssit ;
       }

//开启事务
       @Before("execution(* com.itheima.service.impl.*.*(..))")
       public void beginTransaction() {
            try {
                dbAssit.getCurrentConnection().setAutoCommit(false);
            } catch (SQLException e) {
                e.printStackTrace();
            }
       }

//提交事务
@AfterReturning("execution(* com.itheima.service.impl.*.*(..))")
public void commit() {

     try {
         dbAssit.getCurrentConnection().commit();
     } catch (SQLException e) {
         e.printStackTrace();
     }
}

//回滚事务
       @AfterThrowing("execution(* com.itheima.service.impl.*.*(..))")
       public void rollback() {
            try {
                dbAssit.getCurrentConnection().rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
       }

//释放资源
       @After("execution(* com.itheima.service.impl.*.*(..))")
       public void release() {
            try {
                dbAssit.releaseConnection();
            } catch (Exception e) {
                e.printStackTrace();
            }
       }

/**
        * 环绕通知
        * @param pjp
        * @return
        */
       @Around("execution(* com.itheima.service.impl.*.*(..))")
       public Object transactionAround(ProceedingJoinPoint pjp) {
            //定义返回值
            Object rtValue = null;
            try {
                //获取方法执行所需的参数
                Object[] args = pjp.getArgs();
                //前置通知：开启事务
                beginTransaction();
                //执行方法
                rtValue = pjp.proceed(args);
                //后置通知：提交事务
                commit();
            }catch(Throwable e) {
                //异常通知：回滚事务
                rollback();
                e.printStackTrace();
            }finally {
                //最终通知：释放资源
                release();
            }
            return rtValue;
       }

@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
       private void pt1() {}

       引用方式：
       /**
        * 环绕通知
        * @param pjp
        * @return
        */
       @Around("pt1()")//注意：千万别忘了写括号
       public Object transactionAround(ProceedingJoinPoint pjp) {
            //定义返回值
            Object rtValue = null;
            try {
                //获取方法执行所需的参数
                Object[] args = pjp.getArgs();
                //前置通知：开启事务
                beginTransaction();
                //执行方法
                rtValue = pjp.proceed(args);
                //后置通知：提交事务
                commit();
            }catch(Throwable e) {
                //异常通知：回滚事务
                rollback();
                e.printStackTrace();
            }finally {
                //最终通知：释放资源
                release();
            }
            return rtValue;
       }

@Configuration
       @ComponentScan(basePackages="com.itheima")
       @EnableAspectJAutoProxy
       public class SpringConfiguration {
       }

@Configuration
public class SpringConfiguration {
}
//注意：
//我们已经把配置文件用类来代替了，但是如何配置创建容器时要扫描的包呢？
//请看下一个注解

@Configuration
@ComponentScan("com.itheima")
public class SpringConfiguration {
}
//注意：
//我们已经配置好了要扫描的包，但是数据源和 JdbcTemplate 对象如何从配置文件中移除呢？
//请看下一个注解

public class JdbcConfig {
/**
* 创建一个数据源，并存入 spring 容器中
* @return
*/
@Bean(name="dataSource")
public DataSource createDataSource() {
		try {
			ComboPooledDataSource ds = new ComboPooledDataSource();
			ds.setUser("root");
			ds.setPassword("1234");
			ds.setDriverClass("com.mysql.jdbc.Driver");
			ds.setJdbcUrl("jdbc:mysql:///spring_day02");
			return ds;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
    
/**
* 创建一个 DBAssit，并且也存入 spring 容器中
* @param dataSource
* @return
*/
@Bean(name="dbAssit")
public DBAssit createDBAssit(DataSource dataSource) {
	return new DBAssit(dataSource);
	}
}
//注意:
//我们已经把数据源和 DBAssit 从配置文件中移除了，此时可以删除 bean.xml 了。
//但是由于没有了配置文件，创建数据源的配置又都写死在类中了。如何把它们配置出来呢？
//请看下一个注解。

public class JdbcConfig {
	@Value("${jdbc.driver}")
	private String driver;
    
	@Value("${jdbc.url}")
	private String url;
    
	@Value("${jdbc.username}")
	private String username;
    
	@Value("${jdbc.password}")
	private String password;
	/**
* 创建一个数据源，并存入 spring 容器中
* @return
*/
	@Bean(name="dataSource")
	public DataSource createDataSource() {
		try {
			ComboPooledDataSource ds = new ComboPooledDataSource();
			ds.setDriverClass(driver);
			ds.setJdbcUrl(url);
			ds.setUser(username);
			ds.setPassword(password);
			return ds;
		}
		catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}



jdbc.properties 文件：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/day44_ee247_spring
jdbc.username=root
jdbc.password=1234
//注意：
//此时我们已经有了两个配置类，但是他们还没有关系。如何建立他们的关系呢？
//请看下一个注解。 

@Configuration
@ComponentScan(basePackages = "com.itheima.spring")
@Import({JdbcConfig.class})
public class SpringConfiguration {
    
}

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig{
    
}
注意：
我们已经把要配置的都配置好了，但是新的问题产生了，由于没有配置文件了，如何获取容器呢？
请看下一小节。

ApplicationContext ac = 
new *AnnotationConfigApplicationContext(SpringConfiguration.class);//也可以写多个class

@RunWith(SpringJUnit4ClassRunner.class)
public class AccountServiceTest {
    
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations= {"classpath:bean.xml"})
public class AccountServiceTest {
    
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations= {"classpath:bean.xml"})
public class AccountServiceTest {
	@Autowired
	private IAccountService as ;
}