bean的作用域

1.项目目录

2.Student.java

package com.atguigu.ioc.scope;

public class Student {
    private Integer sid;
    private String sname;
    public Student() {
        System.out.println("Student 无参构造方法");
    }
    public Integer getSid() {
        return sid;
    }
    public void setSid(Integer sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
//    @Override
//    public String toString() {
//        return "Student [sid=" + sid + ", sname=" + sname + "]";
//    }
}

3.scope.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="student" class="com.atguigu.ioc.scope.Student" scope="singleton">
        <property name="sid" value="1001"></property>
        <property name="sname" value="张三"></property>
    </bean>

</beans>

4.Test.java

package com.atguigu.ioc.scope;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args){
        /**
         * 若spring中有单例模式（singleton）的bean，在初始化容器时就会创建此对象
         * 而多例即原型(prototype)的bean，会在使用时创建
         */
        ApplicationContext ac = new ClassPathXmlApplicationContext("scope.xml");
        
//        Student student1 = ac.getBean("student",Student.class);
//        Student student2 = ac.getBean("student",Student.class);
//        
//        System.out.println(student1);
//        System.out.println(student2);
    }
}

FactoryBean

Spring中有两种类型的bean，一种是普通bean，另一种是工厂bean，即FactoryBean。工厂bean跟普通bean不同，其返回的对象不是指定类的一个实例，其返回的是该工厂bean的getObject方法所返回的对象。
示例：
1.项目目录

2.Car.java

package com.atguigu.spring.factorybean;

public class Car {
    private String brand;
    private Double price;
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    @Override
    public String toString() {
        return "Car [brand=" + brand + ", price=" + price + "]";
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    
}

3.MyFactory.java

package com.atguigu.spring.factorybean;

import org.springframework.beans.factory.FactoryBean;

public class MyFactory implements FactoryBean<Car>{
    @Override
    public Car getObject() throws Exception {
        Car car = new Car();
        car.setBrand("奥迪");
        car.setPrice(200000.0);
        return car;
    }

    @Override
    public Class<?> getObjectType() {
        return Car.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

4.factory-bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 工厂bean -->
    <bean id="factory" class="com.atguigu.spring.factorybean.MyFactory"></bean>
</beans>

5.Test.java

package com.atguigu.spring.factorybean;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext ac = new ClassPathXmlApplicationContext("factory-bean.xml");
        Object bean = ac.getBean("factory");
        System.out.println(bean);
    }
}

6.运行结果
Car [brand=奥迪, price=200000.0]

属性赋值-字面量和ref

spring管理对象时，可以使用标签给对象的属性赋值。
1.字面量


…..
2.外部已声明的bean引用其他的bean(使用ref属性)
3.内部bean
4.集合属性赋值（list/array/set）
示例：
1.项目目录

2.Student.java

package com.atguigu.spring.di;

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private Double score;
    private Teacher teacher;
    
    
    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public Double getScore() {
        return score;
    }
    
    public void setScore(Double score) {
        this.score = score;
    }
    
    public Integer getId() {
        return id;
    }
    
    public void setId(Integer id) {
        this.id = id;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public Integer getAge() {
        return age;
    }
    
    public void setAge(Integer age) {
        this.age = age;
    }
    
    public String getSex() {
        return sex;
    }
    
    public void setSex(String sex) {
        this.sex = sex;
    }
    
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", score=" + score
                + ", teacher=" + teacher + "]";
    }

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    public Student(Integer id, String name, Integer age, String sex) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    
    public Student(Integer id, String name, Double score, String sex){
        this.id = id;
        this.name = name;
        this.score = score;
        this.sex = sex;
    }
}

3.Teacher.java

package com.atguigu.spring.di;

import java.util.List;
import java.util.Map;

public class Teacher {
    private Integer tid;
    
    private String tname;
    
    private List<String> cls;
    
    private List<Student> students;
    
    private Map<String, String> bossMap;
    
    public Map<String, String> getBossMap() {
        return bossMap;
    }
    public void setBossMap(Map<String, String> bossMap) {
        this.bossMap = bossMap;
    }
    public List<Student> getStudents() {
        return students;
    }
    public void setStudents(List<Student> students) {
        this.students = students;
    }
    public List<String> getCls() {
        return cls;
    }
    public void setCls(List<String> cls) {
        this.cls = cls;
    }
    public Integer getTid() {
        return tid;
    }
    public void setTid(Integer tid) {
        this.tid = tid;
    }
    public String getTname() {
        return tname;
    }
    public void setTname(String tname) {
        this.tname = tname;
    }
    @Override
    public String toString() {
        return "Teacher [tid=" + tid + ", tname=" + tname + ", cls=" + cls + ", students=" + students + ", bossMap="
                + bossMap + "]";
    }
    
    
}

5.beans-di.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <bean id="s1" class="com.atguigu.spring.di.Student">
        <!-- 通过set方法注入 -->
        <property name="id" value="10010"></property>
        <!-- 
            <property name="id">
                <value>10010</value>
            </property>
         -->
         
        <property name="name" value="张三"></property>
        <property name="age" value="23"></property>
        <property name="sex" value="男"></property>
    </bean>
        
    <bean id="s2" class="com.atguigu.spring.di.Student">
        <!-- 通过构造方法注入 -->
        <constructor-arg value="10086"></constructor-arg>
        <constructor-arg value="李四"></constructor-arg>
        <constructor-arg value="24"></constructor-arg>
        <constructor-arg value="女"></constructor-arg>
    </bean>
    
    <bean id="s3" class="com.atguigu.spring.di.Student">
        <!-- 通过构造方法注入 -->
        <constructor-arg value="10022"></constructor-arg>
        <constructor-arg value="王五"></constructor-arg>
        <constructor-arg value="90" index="2" type="java.lang.Double"></constructor-arg>
        <constructor-arg value="女"></constructor-arg>
    </bean>
    
    <!-- Namespaces勾选p（beans标签会增加内容xmlns:p="http://www.springframework.org/schema/p"） -->
    <bean id="s4" class="com.atguigu.spring.di.Student" p:id="10033" p:name="赵六" p:age="26" p:sex="男" p:teacher-ref="teacher"></bean>
    
    <!-- 给bean的级联属性赋值 -->
    <bean id="s5" class="com.atguigu.spring.di.Student">
        <property name="id" value="10055"></property>
        <property name="name" value="张三三"></property>
        <property name="age" value="23"></property>
        <property name="sex" value="男"></property>
        <property name="teacher" ref="teacher"></property>
        
        <!-- 级联测试 给bean的级联属性赋值-->
        <property name="teacher.tname" value="小红"></property>
    </bean>
        
    <!-- 外部已声明的bean、引用其他的bean -->
    <bean id="teacher" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="10000"></property>
        <property name="tname" value="小明"></property>
    </bean>
    
    <!-- 内部bean -->
    <bean id="s6" class="com.atguigu.spring.di.Student">
        <property name="id" value="10066"></property>
        <property name="name" value="崔八"></property>
        <property name="age" value="18"></property>
        <property name="sex" value="男"></property>
        <property name="teacher">
            <bean id="tt" class="com.atguigu.spring.di.Teacher">
                <property name="tid" value="2222"></property>
                <property name="tname" value="admin"></property>
            </bean>
        </property>
    </bean>
    <!-- 定义在某个bean内部的bean，只能在当前bean中使用 -->
    <!-- 
        <bean id="s7" class="com.atguigu.spring.di.Student">
            <property name="id" value="10066"></property>
            <property name="name" value="崔八"></property>
            <property name="age" value="18"></property>
            <property name="sex" value="男"></property>
            <property name="teacher" ref="tt">
            </property>
        </bean>
     -->
     
     <!-- list属性赋值1 -->
     <bean id="t1" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="0000"></property>
        <property name="tname" value="佟老师"></property>
        <property name="cls">
            <list>
                <value>A</value>
                <value>B</value>
                <value>C</value>
            </list>
        </property>
     </bean>
     
     <!-- list属性赋值2 -->
     <bean id="t2" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="10002"></property>
        <property name="tname" value="婷姐"></property>
        <property name="students">
            <list>
                <ref bean="s1"/>
                <ref bean="s2"/>
                <ref bean="s3"/>
            </list>
        </property>
     </bean>
     
     <!-- array属性赋值 -->
     <!-- set属性赋值 -->
     
     <!-- map属性赋值 -->
     <bean id="t3" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="10003"></property>
        <property name="tname" value="admin"></property>
        <property name="bossMap">
            <map>
                <entry>
                    <key>
                        <value>10001</value>
                    </key>
                    <value>佟老师</value>
                </entry>
                
                <entry>
                    <key>
                        <value>10002</value>
                    </key>
                    <value>陈老师</value>
                </entry>
            </map>
        </property>
     </bean>
     
     <bean id="t4" class="com.atguigu.spring.di.Teacher">
        <property name="tid" value="10004"></property>
        <property name="tname" value="root"></property>
        <property name="students" ref="students"></property>
     </bean>
    
    <util:list id="students">
        <ref bean="s4"/>
        <ref bean="s5"/>
        <ref bean="s6"/>
    </util:list>
    
    <util:map id="map">
        <entry>
            <key>
                <value>1</value>
            </key>
            <value>张三</value>
        </entry>
    </util:map>
</beans>

6.Test.java

package com.atguigu.spring.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans-di.xml");
        
        Student s1 = ac.getBean("s1", Student.class);
        Student s2 = ac.getBean("s2", Student.class);
        Student s3 = ac.getBean("s3", Student.class);
        Student s4 = ac.getBean("s4", Student.class);
        Student s5 = ac.getBean("s5", Student.class);
        Student s6 = ac.getBean("s6", Student.class);
        Teacher t1 = ac.getBean("t1", Teacher.class);
        Teacher t2 = ac.getBean("t2", Teacher.class);
        Teacher t3 = ac.getBean("t3", Teacher.class);
        Teacher t4 = ac.getBean("t4", Teacher.class);
        
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println(s5);
        System.out.println(s6);
        System.out.println(t1);
        System.out.println(t2);
        System.out.println(t3);
        System.out.println(t4);
    }
}

依赖注入的两种方式

1. 通过bean的setXxx()方法赋值
2. 通过bean的构造器赋值

   示例

3. 项目目录
   

2.创建Student.java

package com.atguigu.spring.di;

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private Double score;
    public Double getScore() {
        return score;
    }
    public void setScore(Double score) {
        this.score = score;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", score=" + score + "]";
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(Integer id, String name, Integer age, String sex) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    
    public Student(Integer id, String name, Double score, String sex){
        this.id = id;
        this.name = name;
        this.score = score;
        this.sex = sex;
    }
}

3.创建beans-di.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="s1" class="com.atguigu.spring.di.Student">
        <!-- 通过set方法注入 -->
        <property name="id" value="10010"></property>
        <property name="name" value="张三"></property>
        <property name="age" value="23"></property>
        <property name="sex" value="男"></property>
    </bean>
        
    <bean id="s2" class="com.atguigu.spring.di.Student">
        <!-- 通过构造方法注入 -->
        <constructor-arg value="10086"></constructor-arg>
        <constructor-arg value="李四"></constructor-arg>
        <constructor-arg value="24"></constructor-arg>
        <constructor-arg value="女"></constructor-arg>
    </bean>
    
    <bean id="s3" class="com.atguigu.spring.di.Student">
        <!-- 通过构造方法注入 -->
        <constructor-arg value="10022"></constructor-arg>
        <constructor-arg value="王五"></constructor-arg>
        <constructor-arg value="90" index="2" type="java.lang.Double"></constructor-arg>
        <constructor-arg value="女"></constructor-arg>
    </bean>

    <!-- Namespaces勾选p（beans标签会增加内容xmlns:p="http://www.springframework.org/schema/p"） -->
    <bean id="s4" class="com.atguigu.spring.di.Student" p:id="10033" p:name="赵六" p:age="26" p:sex="男"></bean>
</beans>

4.编写测试类

package com.atguigu.spring.di;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans-di.xml");
        
        Student s1 = ac.getBean("s1", Student.class);
        Student s2 = ac.getBean("s2", Student.class);
        Student s3 = ac.getBean("s3", Student.class);
        Student s4 = ac.getBean("s4", Student.class);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
    }

}

spring简单案例

使用软件：STS

下载地址

搭建spring运行时环境

1.加入JAR包
1)Spring自身JAR包：spring-framework-4.0.0.RELEASE\libs目录下
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELE2ASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar
2)commons-logging-1.1.1.jar
注：将以上所有的jar包复制到项目中的lib目录下并全选所有jar包–>右键–>build path–>config bulid path
2.在Spring Tool Suite工具中通过如下步骤创建Spring的配置文件
1)File->New->Spring Bean Configuration File
2)为文件取名字 例如：applicationContext.xml

创建一个类：Person.java

package com.atguigu.spring.mod;

public class Person {
    private Integer id;
    private String name;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + "]";
    }
    
}

常规方法操作对象

创建一个测试类Test.java

package com.atguigu.spring.mod;

public class Test {
    public static void main(String[] args){
        Person person = new Person();
        person.setId(1);
        person.setName("zhangsan");
        System.out.println(person);
    }
}

spring管理对象

1.创建applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 命名空间 规定当前的文件里面能写什么-->

    <!--
        <bean>：定义spring管理的一个对象
        id:该对象的唯一标识，注意不能重复,在类型获取bean的过程中可以不设置
        class:该对象所属类的全限定名 
    -->
    
    <!-- 通过反射创建对象 -->
    <bean id="person" class="com.atguigu.spring.mod.Person">
        <!--
            <property>:为对象的某个属性赋值
            name:属性名
            value:属性值 
        -->
        <property name="id" value="1111"></property>
        <property name="name" value="小明"></property>
    </bean>
    
</beans>

2.创建一个测试类TestBySpring.java

package com.atguigu.spring.mod;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBySpring {

    public static void main(String[] args) {
        //初始化容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        //通过getBean()获取对象
        Person person = (Person) ac.getBean("person");
        System.out.println(person);

    }
}

注：IOC和DI
反转控制（IOC）：对象的管理权（创建、赋值等）由程序员交给了spring容器
依赖注入（DI）:bean对象依赖于属性 向属性注入资源（赋值）
总结: IOC 就是一种反转控制的思想， 而DI是对IOC的一种具体实现。

Java中的6大框架

6大框架
1)structs1
2)structs2
3)hibernate
4)spring
5)springMVC
6)mybatis
SSM
SSM=spring+springMVC+mybatis
框架分类
MVC框架：struts1(封装了servlet),struts2(封装了filter),springMVC
持久层框架：hibernate,mybatis
整合型框架，设计型框架：spring

事务

当我们一次需要执行多条sql语句时就要考虑控制事务以避免出现一些错误。
例如：当我们从一个账户给另一个账户转账时，假设第一个账户的余额已经扣除，此时电脑断电了，
第二个账户的余额也没有增加；为了避免此类事情的发生，我们可以对事物进行控制，要么增扣除和增加都成功，
要么扣除、增加都失败。
创建表user

CREATE TABLE user(
id INT PRIMARY KEY AUTO_INCREMENT NOT NULL,
NAME VARCHAR(20),
balance DOUBLE
);

创建测试类Test1.java

package com.oracle.test;

import java.sql.SQLException;

import org.apache.commons.dbutils.QueryRunner;

import com.oracle.utils.DataSourceUtils;

public class Test1 {

    public static void main(String[] args){
        try {
            //开启事务
            DataSourceUtils.startTransaction();
            //创建QueryRunner对象
            QueryRunner qr = new QueryRunner();
            //编写sql语句
            String sql1 = "update user set balance=balance-500 where id=1";
            String sql2 = "update user set balance=balance+500 where id=2";
            //执行sql
            qr.update(DataSourceUtils.getConnection(), sql1);
            
            //失败
            int c=100/0;
            
            qr.update(DataSourceUtils.getConnection(), sql2);
            //事务提交
            DataSourceUtils.commitAndRelease();
            //关闭事务
            DataSourceUtils.closeConnection();
        } catch (Exception e) {
            //失败则回滚
            try {
                DataSourceUtils.rollback();
            } catch (Exception e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        }
    }

}

QueryRunner和数据库增删改查操

基于JavaWeb项目开发 | jdbc中的配置编写以下代码实现数据库的增删改查（CRUD）。
在test1数据库中建表dept

create table dept(
int id primary key auto_increment not null,
varchar(20) name
)

Dept.java（JavaBean）

package com.oracle.bean;

public class Dept {
    private int id;
    private String name;
    public Dept() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Dept(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    
}

新建一个Test类实现数据库增删改查操作

package com.oracle.test;

import java.sql.SQLException;
import java.util.List;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import com.oracle.bean.Dept;
import com.oracle.utils.DataSourceUtils;

public class Test {
    
    public static void main(String[] args) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr = new QueryRunner(DataSourceUtils.getDataSource());
        
        //增加数据
        //String sql = "insert into dept(name) values(?)";
        //qr.update(sql, "需求部");
        
        //修改数据
        //String sql = "update dept set name=? where id=?";
        //qr.update(sql, "需求组", 4);
        
        //删除数据
        //String sql = "delete from dept where id=?";
        //qr.update(sql, 4);
        
        //查询数据
        //（1）查询结果为一行
        //String sql = "select * from dept where id=?";
        //Dept d = qr.query(sql, new BeanHandler<>(Dept.class), 1);
        //System.out.println(d.getId());
        //System.out.println(d.getName());
        
        //（2）查询结果为多行
//        String sql = "select * from dept";
//        List<Dept> list = qr.query(sql, new BeanListHandler<>(Dept.class));
//        for(Dept d:list) {
//            System.out.println(d.getId());
//            System.out.println(d.getName());
//        }
        
        //（2）查询结果为聚合函数
        String sql = "select count(*) from dept";
        
        int i = ((Long) qr.query(sql, new ScalarHandler())).intValue();
        
        System.out.println(i);
    }
}

jdbc

在使用Java语言进行开发时，我们可以使用jdbc操作数据库；实际开发中我们通常直接导入数据库连接池（c3p0-0.9.1.2.jar）、
数据库驱动（mysql-connector-java-5.0.4-bin.jar）和简化jdbc操作的类库（commons-dbutils-1.4.jar）；并在c3p0-config.xml中配置数据库。

数据库配置（c3p0-config.xml）
配置数据库的用户名、密码、驱动以及要连接的数据库
（本例连接用户名为root、密码为root、数据库驱动为mysql数据库驱动、连接的数据库为本地的test1数据库）

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <default-config>
        <property name="user">root</property>
        <property name="password">root</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/test1</property>
    </default-config> 
</c3p0-config> 

注：以上三个jar包可在网上通过名称搜索自行下载。

SQL语句实例大全

SQL语句分类

1. DDL(Data Definition Language)数据定义语言
   用来定义数据库对象：数据库，表，列等。关键字：create, drop,alter等
   DDL参考
2. DML(Data Manipulation Language)数据操作语言
   用来对数据库中表的数据进行增删改。关键字：insert, delete, update等
3. DQL(Data Query Language)数据查询语言
   用来查询数据库中表的记录(数据)。关键字：select, where等
4. DCL(Data Control Language)数据控制语言(了解)
   用来定义数据库的访问权限和安全级别，及创建用户。关键字：GRANT， REVOKE等
   注：重点关注DML、DQL；实际开发中我们可以使用数据库软件来创建数据库、表、列等（DDL了解即可）；DCL为DBA关注的事情。