Spring介绍

• （1）什么是Spring?
  Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架
  以 IoC- （Inverse Of Control：反转控制）和 AOP- （Aspect Oriented Programming：面向切面编程）为内核
• （2）Spring有什么特点？
  提供了展现层 SpringMVC
  持久层 Spring JDBC
  还能整合开源世界众多著名的第三方框架和类库
  业务层事务管理AOP
  方便解耦，简化开发IOC
  Java源码是经典学习范例
  逐渐成为使用最多的 Java EE 企业应用开源框架

Spring架构体系

• Spring架构体系?
  （1）Test :用于测试使用
  （2）Core container：核心容器，就是用于装Java Bean对象
  （3）AOP：切面编程
  （4）Aspects：提供了与AspectJ的集成
  （5）Data access：数据访问。用于访问操作我们的数据库。支持持久层的操作
  jdbcTemplate mybatis
  （6）Web：用于支持数据展示层，支持http请求
  （7）Transactions：用于支持事物处理。用于解决业务层的事物处理问题。
  编程式事务管理和声明式事务管理.

功能设计

• (1)列表
• (2)添加
• (3)删除
• (4)编辑

定义数据库表与实体类

• (1)定义Product类

public class Product {
    
    
    private String id;
    private String name;
    private Double price;

编写sql

• (1)创建数据库
• (2)定义表
• (3)操作数据库

drop database db_product;
create  database db_product;#创建产品库
use db_product; #选择

create table product(
	id varchar(200) primary key ,
	name varchar(20),
	price double
)

# 查询所有
select * from product ;
# 查询1条
select * from product where id = 1 ;
# 删除1条
delete from product where id = 1 ;
# 添加1条
insert into  product(id,name,price)values('1','iphone12',123);
# 修改1条
update product set name = 'iphone13',price=126 where id = 1;

编写功能逻辑

• (1)编写逻辑再实现类的具体细节
• (2)运行测试保存每个方法没有bug

public class TestProductDao {

    @Test
    public void test01(){
        System.out.println(1);
        //1:定义一个类名 ProductDao
        //2:创建出来ProductDao
        IProductDao dao = new ProductDao();
        List<Product> list = dao.findAll(); //查所有
       Product p = dao.findById("2"); //查1条
        System.out.println(list);
       System.out.println(p);
 //       dao.deleteById("1"); //删除1条
        Product product= new Product();
        product.setName("2+");
        product.setPrice(333.00);

       //dao.saveProduct(product);//添加1条
        product.setId("88327e1b-edc5-43a2-81de-a07517f19181");
        //dao.updateProduct(product);//修改1条
    }
}

添加JdbcTemplate

• (1)在pom.xml中添加jdbc驱动
• (2)添加spring-jdbc依赖
• (3)执行pom.xml

   <dependencies>
<!--       添加单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
        <!--     添加mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.30</version>
        </dependency>
   <!--    添加spring的操作数据库的模块spring jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.1</version>
        </dependency>


    </dependencies>

创建数据源编写删除方法

• (1)初始化数据源
• (2)初始化JdbcTemplate
• (3)编写删除 方法

//1 数据库访问层 本质就是执行sql
public class ProductDao implements IProductDao {
    
    

    private static JdbcTemplate jdbcTemplate;//jdbc模板，就是spring提供的用来操作数据库的对象
    static {
    
    
        jdbcTemplate = new JdbcTemplate();
        //2只要两个方法就可以完成增删改查query update
        //创建spring自带的数据源
        DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
        //四大信息
        driverManagerDataSource.setUsername("root");
        driverManagerDataSource.setPassword("123456");
        driverManagerDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        driverManagerDataSource.setUrl("jdbc:mysql://localhost:3306/db_product");
        jdbcTemplate.setDataSource(driverManagerDataSource);
    }
    //3 以下方法都可以使用jdbcTemplate去读写数据库

编写删除方法

    public void deleteById(String id) {
    
    
        //4 ? 是占位符
        jdbcTemplate.update("delete from product where id = ?;",id);//参1 sql  参2 参数
    }

编写修改与添加方法

• (1)添加，程序需要产生uuid
• (2)修改，对象自己有id

 //5:
    public void updateProduct(Product product) {
    
    
        jdbcTemplate.update("update product set name = ?,price=? where id = ?;",product.getName(),product.getPrice(),product.getId());//参1 sql  参2 参数
    }

    public void saveProduct(Product product) {
    
    
        //程序自动产生编号id,id是唯一的，是不能重复 timestap  uuid
        String id = UUID.randomUUID().toString();
        System.out.println("id = "+id);
        //添加页面不可能让用户输入id
        product.setId(id);
        jdbcTemplate.update("insert into  product(id,name,price)values(?,?,?);",product.getId(),product.getName(),product.getPrice());//参1 sql  参2 参数
    }

编写查询方法

• (1)表的字段与类的成员变量要有对应关系
• (2)如：不能把id的值赋值给对象的name
• (3)需要定义BeanPropertyRowMapper
• (4)增删改调update方法，查询方法调query

  //6:
    BeanPropertyRowMapper<Product> mapper=new BeanPropertyRowMapper<Product>(Product.class);
    public List<Product> findAll() {
    
    
        //定义一个关系，防止数据赋值出错RowMapper
       List<Product> list = jdbcTemplate.query("select * from product ;",mapper);//参1 select 参2 mapper 参3 赋值
        return list;
    }

    public Product findById(String id) {
    
    
        List<Product> list = jdbcTemplate.query("select * from product where id = ? ;", mapper, id);
        if (list.size() > 0) {
    
    
            return list.get(0);
        } else {
    
    
            return null;
        }
    }

编写业务类ProductService

• (1)抽取ProductDao的接口IProductDao
• (2)复制ProductDao的接口IProductDao 改为IProductService
• (3)如果没有复杂的计算，Service内一般直接调用dao的方法

public interface IProductDao {
    
    
    List<Product> findAll();

    Product findById(String id);

    void deleteById(String id);

    //5:
    void updateProduct(Product product);

    void saveProduct(Product product);
}

复制得到IProductService

public interface IProductService {
    
    
    List<Product> findAll();

    Product findById(String id);

    void deleteById(String id);

    //5:
    void updateProduct(Product product);

    void saveProduct(Product product);
}

工厂模式编写getBean方法1

• (1)创建application.properties文件
• (2)定义key与value
• (3)让工厂类来读取application.properties
• (4)定义getBean方法
  

# 1 register class
#  key=value
productDao=com.huawei.dao.ProductDao
productService=com.huawei.service.ProductService

工厂模式编写getBean方法2

• (1)定义自己的ioc容器，即一个Map<String,Object> iocContainer
• (2)getBean内部先 判断是否存在id
• (3)存在就返回对象
• (4)否则就创建对象并保存

public class MyBeanFactory {
    
    
    //当前就是一个集合，以后在spring出现时，叫做ioc容器，帮spring创建对象 ，保存对象 ，查找对象
    private static Map<String,Object> iocContainer=new HashMap<String,Object>();
    private static  Properties p;
    //1:
    static {
    
    //静态代码，只有在类加载的时候执行一次，且仅有一次
        InputStream is = MyBeanFactory.class.getClassLoader().getResourceAsStream("applicaton.properties");
        //2.properties有对应的类来解析Properties
        p = new Properties();
        try {
    
    
            p.load(is);
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
    }

    public <T> T getBean(String id) {
    
     //T 读取接收变量的类型
        if(iocContainer.containsKey(id)){
    
    
            return (T)iocContainer.get(id);//如果容器中存在该对象 就返回，不用创建
        }else{
    
    
            String className = p.getProperty(id);
            //使用反射可以创建对象
            try {
    
    
                Class<?> clz = Class.forName(className);
                Object obj = clz.newInstance();//new ProductDao
                iocContainer.put(id,obj);//首次创建，同时保存到容器中
                return (T) obj;
            } catch (ClassNotFoundException e) {
    
    
                e.printStackTrace();
            } catch (InstantiationException e) {
    
    
                e.printStackTrace();
            } catch (IllegalAccessException e) {
    
    
                e.printStackTrace();
            }
            return null;
        }

    }
}

SpringIOC入门

• (1)添加spring-context依赖
• (2)创建ioc容器
• (3)调用getBean方法

pom.xml

<!--    spring容器-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>

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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
<!--    配置  一个bean标签表示一个new  class指定类 id指定编号 -->

    <bean id="productDao" class="com.huawei.dao.ProductDao"></bean>
    <bean id="productService" class="com.huawei.service.ProductService"></bean>
</beans>

public class TestSpringIOC {
    
    

    @Test
    public void test01(){
    
    
        //1:添加依赖 pom.xml

        //2:配置文件 applicationContext.xml

        //3:创建IOC容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        IProductDao productDao = (IProductDao) context.getBean("productDao");
        System.out.println(productDao);
    }
}