java入门作业-spring框架IOC模块

牛大了2023

于 2023-02-12 17:33:36 发布

阅读量140

点赞数 2

分类专栏： java 文章标签： java spring 开发语言

本文链接：https://blog.csdn.net/m0_62237233/article/details/128962793

版权

java 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

一、简介

上一章用到了DaoFactory这个概念，但如果一个工程。里面有100个类需要实例化，并且用单例，怎么办。同理sqlsessionFactory 也是这样，而且它的代码有点多，能不能优化一下？

可以使用spring来管理这些对象的实例化。

今天使用到是spring框架里面一个模块 IOC模块
IOC控制反转：其实就是帮助我们做类的实例化，我们自己不需要去实例化对象了

原理：把写好的对象的控制权交给了spring框架，让它帮助我们去控制对象的生命周期（创建，销毁...）然后IOC会由一个专门的容器来帮助创建对象，将所有的类都在spring容器里面登记，当需要某个对象就告诉spring ，然后spring就会在适当的时候，把想要的对象主动交给我们，以前都是由我们自己控制对象的生命周期，现在在IOC中，所有对象，都是spring控制，这就叫控制反转。

文件位置

记得在src内写入spring的配置

<?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"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
			https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
			https://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/util
			https://www.springframework.org/schema/util/spring-util.xsd">

<!--    bean 作用：用来实例化对象，只要写了个标签，spring在启动后，帮你实例化好-->
<!--    id ：标签bean 对象 变量名   class:类的全限定名   包名+类名-->
<!--    <bean id="aaa" class="pojo.Admin">-->

<!--        <property name="adminName" value="张三"></property>-->
<!--        <property name="adminAge" value="18"></property>-->
<!--    </bean>-->
<!--        扫描 pojo 包底下的所有的pojo类-->
        <context:component-scan base-package="pojo"></context:component-scan>

<!--    读取配置文件  配置最好在src下， id ：命名 不能重复且不为空   location：文件地址   classpath：在src下-->
        <util:properties id="configUtil" location="classpath:config.properties"></util:properties>

</beans>

二、util工具类

链接数据库用

package util;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

public class DBUtil {
    private static Properties pro = new Properties();
    private static String url;
    private static String driver;
    private static String name;
    private static String pwd;

    static {
        InputStream ins = DBUtil.class.getClassLoader().getResourceAsStream("config.properties");

        try {
            pro.load(ins);
            url = pro.getProperty("url");
            driver = pro.getProperty("driver");
            name = pro.getProperty("name");
            pwd = pro.getProperty("pwd");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static Connection getCone() {

        try {
            Class.forName(driver);
            Connection cone  = DriverManager.getConnection(url,name,pwd);
            return cone;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return null;
    }

    // 关闭的方法
    public static void close(Connection cone) {

        try {

            if (cone != null) {
                cone.close();
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

三、pojo

Admin

package pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component    //这个类现在由spring来管理
public class Admin {

    @Value("老王")   //初始化值
    private String adminName;
    @Value("#{configUtil.age}")
    private Integer adminAge;

    public Admin() {

    }

    public String getAdminName() {
        return adminName;
    }

    public void setAdminName(String adminName) {
        this.adminName = adminName;
    }

    public Integer getAdminAge() {
        return adminAge;
    }

    public void setAdminAge(Integer adminAge) {
        this.adminAge = adminAge;
    }

    @Override
    public String toString() {
        return "Admin{" +
                "adminName='" + adminName + '\'' +
                ", adminAge=" + adminAge +
                '}';
    }
}

AdminInfo

package pojo;

import java.util.Date;

public class AdminInfo {

    private Integer adminId ;
    private String adminName;
    private String adminPwd;
    private Integer roleId;
    private Integer adminState;
    private Date adminCtime;
    private Date adminMtime;

    public AdminInfo() {
    }

    public Integer getAdminId() {
        return adminId;
    }

    public void setAdminId(Integer adminId) {
        this.adminId = adminId;
    }

    public String getAdminName() {
        return adminName;
    }

    public void setAdminName(String adminName) {
        this.adminName = adminName;
    }

    public String getAdminPwd() {
        return adminPwd;
    }

    public void setAdminPwd(String adminPwd) {
        this.adminPwd = adminPwd;
    }

    public Integer getRoleId() {
        return roleId;
    }

    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }

    public Integer getAdminState() {
        return adminState;
    }

    public void setAdminState(Integer adminState) {
        this.adminState = adminState;
    }

    public Date getAdminCtime() {
        return adminCtime;
    }

    public void setAdminCtime(Date adminCtime) {
        this.adminCtime = adminCtime;
    }

    public Date getAdminMtime() {
        return adminMtime;
    }

    public void setAdminMtime(Date adminMtime) {
        this.adminMtime = adminMtime;
    }

    @Override
    public String toString() {
        return "AdminInfo{" +
                "adminId=" + adminId +
                ", adminName='" + adminName + '\'' +
                ", adminPwd='" + adminPwd + '\'' +
                ", roleId=" + roleId +
                ", adminState=" + adminState +
                ", adminCtime=" + adminCtime +
                ", adminMtime=" + adminMtime +
                '}';
    }
}

四、mybatis

首先是上节用到的mybatis。仍然需要用到，创建mybatis-config.xml和config.properties。记得存放自己的数据。

<?xml version="1.0" encoding="UTF-8" ?>     <!-- 声明-->
<!--约束-->
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<!--配置-->
<configuration>
    <environments default="development">
        <environment id="development">    <!--默认用的是哪个数据库环境-->
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/jc0122?useUnicode=ture&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/AdminInfoMapper.xml"/>
    </mappers>
</configuration>

url=jdbc:mysql://localhost:3306/jc0122
driver=com.mysql.cj.jdbc.Driver
name=root
pwd=123456

mapper接口也写上，有根据id修改名字，分页并条件查询，map传递数据。xml配置好和java接口。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mapper.AdminInfoMapper">   <!--表示和哪个接口对应-->

    <resultMap id="myResult" type="pojo.AdminInfo">
<!--        这里的配置是为了告诉系统  数据的字段和实体类的pojo的属性是如何匹配
            id 和result 其实一样，只是为了区分它是主键
          column：数据库的字段名
        property：pojo 的属性名

        和原来
         adminInfo.setAdminId(set.getInt("ADMIN_ID"));
         adminInfo.setAdminName(set.getString("ADMIN_NAME"));
        adminInfo.setAdminPwd(set.getString("ADMIN_PWD"));
-->


        <id column="ADMIN_ID" property="adminId"></id>
        <result column="ADMIN_NAME" property="adminName"></result>
        <result column="ADMIN_PWD" property="adminPwd"></result>
        <result column="ADMIN_CTIME" property="adminCtime"></result>
        <result column="ADMIN_MTIME" property="adminMtime"></result>
        <result column="ADMIN_STATE" property="adminState"></result>
        <result column="ROLE_ID" property="roleId"></result>

    </resultMap>

    <sql id="base_colums">
        admin_id, admin_name, admin_pwd, admin_state, admin_ctime, admin_mtime,role_Id
    </sql>

    <select id="selectAll" resultMap="myResult">
        select admin_id, admin_name, admin_pwd, admin_state, admin_ctime, admin_mtime,role_Id from admin_info
    </select>

    <insert id="insertOne" keyProperty="a.adminId" useGeneratedKeys="true">
<!--        增删改 执行完返回的都是影响的行数   在mybatis如果是int  返回可以不写 -->
        insert into admin_info(admin_id, admin_name, admin_pwd, admin_state, admin_ctime, role_id)
        values(null,#{a.adminName},#{a.adminPwd},1,now(),#{a.roleId})
<!--        #{ 传入sql语句的变量}-->

    </insert>

    <update id="updateById">
        update admin_info set admin_name = #{name} where admin_id = #{id}

    </update>


    <update id="updateById2" parameterType="Map">
        update admin_info set admin_name = #{map.name} where admin_id = #{map.id}
    </update>


    <select id="selectByPage" resultMap="myResult">
        select
            <include refid="base_colums"></include>
        from admin_info
        <where>
            <if test="name != null">
                and admin_name like concat('%',#{name}, '%')
            </if>
            <if test="bdata != null">
                and admin_ctime >= #{bdata}
            </if>
            <if test="edate != null">
                and admin_ctime &lt;= #{edate}
            </if>
            <if test="rid != null">
                and role_id = #{rid}
            </if>
        </where>
            limit #{start}, #{limit}


    </select>




</mapper>

package mapper;

import org.apache.ibatis.annotations.Param;
import pojo.AdminInfo;

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

public interface AdminInfoMapper {

    List<AdminInfo> selectAll();
    Integer insertOne(@Param("a") AdminInfo adminInfo);  //在存入mybatis前取了一个别名(形参) a

    /**
     * 根据idx修改名字
     * @param adminName
     * @param id
     * @return
     */
    Integer updateById(@Param("name") String adminName, @Param("id") Integer id);

    Integer deleteById(@Param("id") Integer id);

    /**
     * 分页并按条件查询   这些条件都是可以为空的，也是可以填写，语句需要组件进行查询
     * @param adminName     姓名
     * @param bdata     注册开始时间
     * @param edate     注册的结束时间
     * @param rid       角色查询
     * @param start     分页开始
     * @param limit     分页条数
     * @return
     */
    List<AdminInfo> selectByPage(@Param("name") String adminName, @Param("bdata") String bdata,
                                 @Param("edate") String edate, @Param("rid") Integer rid,
                                 @Param("start") Integer start, @Param("limit") Integer limit);

    /**
     * Map 来传
     */
    Integer updateById2(@Param("map") Map<String, Object> map);

}

五、主程序

demo

package demo;


import mapper.AdminInfoMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import pojo.AdminInfo;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Demo {

    public static void main(String[] args) throws IOException {


//        System.out.println("DBUtil:" + DBUtil.getCone());
//
//        AdminInfo adminInfo =  DaoFactory.getAdminDAO().selectByNameAndPwd("zhangsan","123456");
//        System.out.println(adminInfo);
//
//        List<AdminInfo> list = DaoFactory.getAdminDAO().selectByPage(0,3);
//        System.out.println(list);


        String resource = "mybatis-config.xml";  //读取配置文件的目录
        InputStream inputStream = Resources.getResourceAsStream(resource);  //加载配置文件
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //从配置文件中获取sqlsession 连接的工厂类
        SqlSession sqlSession = sqlSessionFactory.openSession(); //获取sql语句的操作对象 SQLsession
        System.out.println(sqlSession);
        AdminInfoMapper adminInfoMapper = sqlSession.getMapper(AdminInfoMapper.class);  // 由SQL工厂来管理mapper（dao）

        List<AdminInfo> list = adminInfoMapper.selectAll();
        System.out.println(list);

        AdminInfo adminInfo = new AdminInfo();
        adminInfo.setAdminName("班班2");
        adminInfo.setAdminPwd("123456");
        adminInfo.setRoleId(1);

        int flag =  adminInfoMapper.insertOne(adminInfo);
        System.out.println(flag+"---"+adminInfo.getAdminId());
        //        数据库中增删改是需要提交的 commit  ,平时的数据库的软件默认自动提交的，但是代码中需要手动提交
        if (flag > 0){
            System.out.println("插入成功");
        }

        int flag2 =  adminInfoMapper.updateById("班班二号",adminInfo.getAdminId());

        System.out.println("flag2"+flag2);

        if (flag > 0 && flag2 >0){
            sqlSession.commit();//提交事务到数据库，只有commit以后数据才正在进入数据库中
            System.out.println("业务成功");
        }else {
            sqlSession.rollback();//事务回滚，那这个sqlsession所操作的数据都不生效，
        }

        /**
         * -----------------map-----------------
         */
        Map<String, Object> map =  new HashMap<>();
        map.put("name","zhangsan");
        map.put("id",2);
        adminInfoMapper.updateById2(map);


        List<AdminInfo> list2 = adminInfoMapper.selectAll();
        System.out.println(list2);
        

    }

    

}

demo2

package demo;


import mapper.AdminInfoMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.Admin;
import pojo.AdminInfo;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Demo2 {

    public static void main(String[] args) throws IOException {

        //加载spring的配置文件，
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        Admin admin = context.getBean(Admin.class);
        System.out.println(admin);



    }





}

运行demo1可实现插入

牛大了2023

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java入门作业-spring框架IOC模块

上一章用到了DaoFactory这个概念，但如果一个工程。里面有100个类需要实例化，并且用单例，怎么办。同理sqlsessionFactory 也是这样，而且它的代码有点多，能不能优化一下？可以使用spring来管理这些对象的实例化。今天使用到是spring框架里面一个模块 IOC模块IOC控制反转：其实就是帮助我们做类的实例化，我们自己不需要去实例化对象了。
复制链接

扫一扫