Spring基于注解的IOC以CRUD操作及案例

最新推荐文章于 2021-03-01 15:50:59 发布
最新推荐文章于 2021-03-01 15:50:59 发布
阅读量206 收藏
点赞数
分类专栏： java 文章标签： spring mysql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40395100/article/details/105781750
版权

spring中Ioc的常用注解

@Component 

作用：用于把当前类对象存入spring容器属性。

带此注解的类看为组件，当使用基于注解的配置和类路径扫描的时候，这些类就会被实例化

value：用于指定Bean 的id 。默认当前类名（首字母小写）

@Controller:一般用于表现层

@Service：一般用于业务层

@Repository:一般用于持久层

//默认为userServiceImpl
@Component
public class UserServiceImpl implements UserService {}

 @Autowired

@Autowired 注释对在哪里和如何完成自动连接提供了更多的细微的控制。

作用：@Autowired 自动按照类型注入 。只要容器中有唯一的一个Bean对象类型和要注入的变量类型匹配就注入成功。

@Component
public class UserServiceImpl implements UserService {
    //自动按照类型注入
    @Autowired
    private UserDao userDao;
    public void saveUser() {
        userDao.saveUser();
    }
}

@Qualifier

可能会有这样一种情况，当你创建多个具有相同类型的 bean 时，并且想要用一个属性只为它们其中的一个进行装配，在这种情况下，你可以使用 @Qualifier 注释和 @Autowired 注释通过指定哪一个真正的 bean 将会被装配来消除混乱。

作用：在按照类注入的基础上，再按照名称注入。它在给类成员注入时不能单独使用，但是在给方法参数注入时可以

属性:value:y用于指定注入Bean的id

@Component
public class UserServiceImpl implements UserService {
    @Autowired
    @Qualifier("userDao2")
    private UserDao userDao = null;
    public void saveUser() {
        userDao.saveUser();
    }
}

如果嫌麻烦，可以通过@Resource直接通过name 来指定

@Component
public class UserServiceImpl implements UserService {
//    @Autowired
//    @Qualifier("userDao2")
    @Resource(name="userDao2")
    private UserDao userDao = null;
    public void saveUser() {
        userDao.saveUser();
    }
}

以上三个注入都只能中注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现，另外，集合类型的注入只能通过xml

@Value

作用：用于注入基本类型和String类型的数据

属性：value 用于指定数据的值，他可以使用spring中spel（也就是spring的el表达式） ${表达式}

 @Value("18")
    private int age ;

@Scope 

作用：用于指定bean的作用范围

属性：value 用于指定作用范围的取值，通常取值：singleton prototype

 

案例使用xml方式和注解方式实现的CRUD操作

开发工具：idea maven工程

创建实体类：User

public class User implements Serializable {
    private Integer uid;
    private String uname;
    private String pwd;
    private String sex;
    private Integer age;

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", uname='" + uname + '\'' +
                ", pwd='" + pwd + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}

 创建业务层：

package cn.qlu.service;

import cn.qlu.user.User;

import java.util.List;

public interface UserService {

    /**
     * 查询所有
     * @return
     */
    List<User> findAll();

    /**
     * 根据id查询
     * @return
     */
    User findUserById(Integer uid);

    /**
     * 保存
     * @param user
     */
    void saveUser(User user);

    /**
     * 更新
     * @param user
     */
    void updateUser(User user);

    /**
     * 删除
     * @param uid
     */
    void deleteUser(Integer uid);
}

业务层实现类：

package cn.qlu.service.impl;

import cn.qlu.dao.UserDao;
import cn.qlu.dao.impl.UserDaoImpl;
import cn.qlu.service.UserService;
import cn.qlu.user.User;
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public List<User> findAll() {
        return userDao.findAll();
    }

    public User findUserById(Integer uid) {
        return userDao.findUserById(uid);
    }

    public void saveUser(User user) {
        userDao.saveUser(user);

    }

    public void updateUser(User user) {
        userDao.updateUser(user);

    }

    public void deleteUser(Integer uid) {
        userDao.deleteUser(uid);

    }
}

 

创建持久层及实现类

package cn.qlu.dao;

import cn.qlu.user.User;

import java.util.List;

public interface UserDao {
  
    List<User> findAll();
    User findUserById(Integer uid);
    void saveUser(User user);
    void updateUser(User user);
    void deleteUser(Integer uid);
}

 

 

package cn.qlu.dao.impl;

import cn.qlu.dao.UserDao;
import cn.qlu.user.User;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.stereotype.Component;

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

/**
 * 持久层实现类
 */
public class UserDaoImpl implements UserDao {
    private QueryRunner runner;

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }

    public List<User> findAll() {
        try {
            return runner.query("select * from t_user",new BeanListHandler<User>(User.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public User findUserById(Integer uid) {
        try {
            return runner.query("select * from t_user where uid=?",new BeanHandler<User>(User.class),uid);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public void saveUser(User user) {
        try {
            runner.update(
                    "insert into t_user(uname,pwd,sex,age)values(?,?,?,?)",
                    user.getUname(),user.getPwd(),user.getSex(),user.getAge());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void updateUser(User user) {
        try {
            runner.update(
                    "update t_user set uname=?,pwd=?,sex=?,age=? where uid=?",
                    user.getUname(),user.getPwd(),user.getSex(),user.getAge(),user.getUid());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void deleteUser(Integer uid) {
        try {
            runner.update(
                    "delete from t_user  where uid=?", uid);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

 

 

 

创建bean.xml 首先介绍使用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-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!--配置service对象-->
    <bean id="userService" class="cn.qlu.service.impl.UserServiceImpl">
        <!--注入dao-->
        <property name="userDao" ref="userDao"></property>
    </bean>
    <!--配置dao对象-->
    <bean id="userDao" class="cn.qlu.dao.impl.UserDaoImpl">
        <!--z注入QueryRunner-->
        <property name="runner" ref="runner"></property>
    </bean>
    <!--注入Runner对象-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
    <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/crawler"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    

    <context:component-scan base-package="cn.qlu"/>

<!--    把对象的创建交给spring来管理-->
   <!-- <bean id="userService" class="cn.qlu.service.impl.UserServiceImpl"></bean>

    <bean id="userDao" class="cn.qlu.dao.impl.UserDaoImpl"></bean>-->


</beans>

测试类：

/**
 * 使用Junit单元测试
 */
public class UserServiceTest {


    @Test
    public void testFindAll(){
        //获取容器
        ApplicationContext ac= new ClassPathXmlApplicationContext("bean.xml");
        //得到业务层对象
        UserService userService = ac.getBean("userService",UserService.class);
        //执行方法
        List<User> users = userService.findAll();
        for(User user:users){
            System.out.println(user);
        }


    }

运行结果：

 其他方法类似 这里就不展示了

创建Bean.xml 使用基于注解的案例操作

在这里可以简单的使用注解进行操作

将之前的业务层改成下图所示：

将持久层改成下图所示：

 

将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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <!--需要扫描的包-->
    <context:component-scan base-package="cn.qlu"/>
    <!--注入Runner对象-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/crawler"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>



</beans>

 

再次运行：

 

通过上面两种方式可以看出，注解更加的简单~

 

 

 

 

Zeyababy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring#(一)---spring概览思想
Stock01的博客
08-20 119
一.spring是什么 spring是一个框架,整合了多种技术. spring的特点是IOC(控制反转),AOP(面向切面编程) 1.IOC和AOP两个思想简要理解 IOC:让程序自己动态创建对象,创建对象权利是程序而不是程序员 AOP:在不改变原有代码的情况下,实现插入代码(添加功能) 2.maven导入spring <dependency> <groupId>org.springframework</groupId> <artifac
利用Spring的注解实现账户的CRUD
void
01-24 190
为了用注解实现spring对容器的管理，在各实现类上加上相应注解： 业务层： package com.ethan.service.impl; import com.ethan.dao.AccountDAO; import com.ethan.service.AccountService; import com.ethan.domain.Account; import org.springfram...
spring2.5.6注解以及xml简单ioc入门示例
09-17
spring2.5.6注解以及xml两个简单ioc入门示例项目，导入项目可运行。 同时带有spring-framework-2.5.6-with-docs.zip包
spring简单crud配置文件说明
weixin_30596023的博客
06-18 61
字体设置：代码 14px 文字 幼圆 15px 1.在pom.xml下导入依赖包 （1）Spring四个核心依赖包 <dependency> <groupId>org.springframework</groupId> <arti...
Spring基于xml配置用spring-jdbcTemplate实现简单的增删改查（CRUD）
CenZn的博客
04-24 264
目录结果 导入maven坐标 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLoc...
基于spring-boot+quartz的CRUD任务管理系统.zip
最新发布
05-05
Spring框架具有控制反转（IOC）特性，IOC旨在方便项目维护和测试，它提供了一种通过Java的反射机制对Java对象进行统一的配置和管理的方法。Spring框架利用容器管理对象的生命周期，容器可以通过扫描XML文件或类上...
SpringData Repository接口用法解析
09-07
但是，如果你定义的接口继承了Repository，那么这个接口将会被Spring的IoC（Inversion of Control）容器识别为一个Repository Bean，并且被纳入到Spring的应用上下文中。这样，你就可以在该接口中定义符合特定规则的...
Hibernate、Spring和Struts工作原理及使用理由
10-31
《Hibernate、Spring和Struts工作原理及使用理由详解》 在Java Web开发中，Hibernate、Spring和Struts是三大核心框架，它们各自扮演着不同的角色，共同构建了强大的企业级应用解决方案。 首先，让我们深入了解...
基于Struts+Hibernate+Spring的Web_应用开发
05-25
4. 使用Hibernate API进行CRUD操作，包括Session的打开、关闭、保存、更新、删除、查询等。 5. Hibernate的HQL（Hibernate Query Language）和Criteria API，学习编写面向对象的查询语句，替代传统的SQL。 6. 理解...
spring mvc4.1.6 spring4.1.6 hibernate4.3.11 mysql5.5.25开发环境搭建图文教程
09-02
在这个文件中，你需要配置Spring的IoC容器，但要注意排除@Controller注解的组件，因为这些组件将由Spring MVC负责创建和管理。 在`springmvc-servlet.xml`中，我们将详细配置Spring MVC的行为，包括视图解析器、...
spring 的纯注解配置实现CRUD
liuzuoping的博客
04-01 424
编写实体类 public class Account implements Serializable { private Integer id; private String name; private Float money; @Override public String toString() { return "Account{" ...
Spring之IOC案例分析以及注解案例
qq_36964872的博客
05-28 378
day2.......... 一、spring中IOC的常用注解 1.注解创建对象 @Component 2.自动按照类型注入 如果有唯一一个匹配时，直接注入；若有多个匹配，则首先圈出匹配的对象，接着使用变量名称 作为bean的id在圈定的对象中继续查找，若圈中的对象一样则匹配成功，否则匹配失败； 3.该边作用范围和生命周期的注解 二、基于XML...
Spring IOC AOP 注解实现的简单实例
Vamps
09-23 173
1.IOC 首先定义一个animal接口 public interface Animal { public void eat(); } 定义两个实现类dog和mat @Component public class Dog implements Animal { public Dog(){} @Override public void eat() { ...
Spring纯注解配置，实现数据库的CRUD操作
lierenbiji21的博客
08-26 610
问题引出 纯注解配置是相对注解+xml文件练习中，仍然有部分配置需要使用applicationContext.xml，那么能不能使用注解替换掉所有的xml呢？Spring提供了一些新注解，可以达到这个目标。 请注意：Spring提供的这部分新注解，并非为了完全代替掉XML，只是提供了另外一种配置方案 环境跟上文xml+注解方式配置环境相同 修改的地方之一： xml配置文件被核心控制类取代 import com.mchange.v2.c3p0.ComboPooledDataSource; import
spring基于注解的IOC以及IOC的案例
程序员养成日记
05-30 286
文章目录spring中IOC的常用注解案例使用xml的方式和注解方式实现单表的CRUD操作改造基于注解的IOC案例，使用纯注解的方式实现spring和Junit整合 spring中IOC的常用注解 使用注解首先要在配置文件中引入几行代码，在下面这个链接中搜索"xmlns:context"即可得到这段代码。将其复制到bean.xml配置文件中。链接 作用：告诉spring在创建容器时要扫描的包，配置所需要的标签不是在beans的约束中，而是在一个名称为context名称空间和约束中。 接着就可以写下面这个代码
Mybatis 基于注解的 CRUD 操作
weixin_44470078的博客
07-28 109
Mybatis 基于注解的开发 1. 导入相关的 jar 包 <dependencies> <!-- mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.4.5&
Spring笔记7 基于注解的IoC案例（实现CRUD）
CoCoNutNut的博客
03-04 221
https://www.bilibili.com/video/av47952931 p38~ 文章目录数据库部分在基于xml的案例上修改完整代码项目结构pom.xmlbeans.xml实体类业务层持久层测试方法测试 数据库部分 继续用上次的表 在基于xml的案例上修改 pom.xml不用改 beans.xml名称空间需要修改 在Spring文档中搜索xmlns:context（基于xml...
使用spring ioc基于纯xml配置模拟crud
weixin_43919497的博客
03-01 95
1、需求和技术要求 1.1 需求 实现账户的 CRUD 操作 1.2 技术要求 使用 spring 的 IoC 实现对象的管理 持久层用打印语句模拟 2、环境配置 2.1 maven导入相应的依赖 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactI
仿spring的ioc实现之注解注入的小例子
梦铃之境的专栏
12-26 956
首先，我们先写出一个自定义的注解 package com.test.aonntion; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.T
Spring boot控制层 服务层 mapper层 等是怎样提供服务的
05-31
Spring Boot 是一个基于 Spring 框架的开源 Java Web 框架，提供了一种快速创建可独立运行的生产级 Spring 应用程序的方式。在 Spring Boot 中，控制层、服务层、Mapper 层等都是通过 Spring IoC 容器来提供服务的。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值