spring学习巩固

最新推荐文章于 2024-07-22 09:35:57 发布
最新推荐文章于 2024-07-22 09:35:57 发布
阅读量128 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41302368/article/details/97545752
版权

Spring IOC(xml)

//依赖
 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
    </dependencies>

//Person类
@Component("person")
public class Person {
    private String name;
    private  Integer age;
    //自定义成员变量
    private  Computer computer;
    public Person() {
        super();
    }
    public Person(String name, Integer age, Computer computer) {
        this.name = name;
        this.age = age;
        this.computer = computer;
    }
    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 Computer getComputer() {
        return computer;
    }
    public void setComputer(Computer computer) {
        this.computer = computer;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", computer=" + computer +
                '}';
    }
}
//Cmputer类
public class Computer {
    private  String brand;
    private  String color;
    private  Double price;
    public Computer() {
        super();
    }
    public Computer(String brand, String color, Double price) {
        this.brand = brand;
        this.color = color;
        this.price = price;
    }
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "brand='" + brand + '\'' +
                ", color='" + color + '\'' +
                ", price=" + price +
                '}';
    }
}

xml配置

<context:component-scan base-package="zlb.demo01"></context:component-scan>
//通过set方法注入属性
<!--配置Person-->
        <bean id="person" class="zlb.demo01.Person">
            <property name="name" value="胡歌"></property>
            <property name="age" value="18"></property>
            <property name="computer" ref="computer"></property>
         </bean>
         <!--配置computer-->
        <bean id="computer" class="zlb.demo01.Computer">
            <property name="brand" value="华硕"></property>
            <property name="color" value="白色"></property>
            <property name="price" value="5000.00"></property>
        </bean>

//通过构造器注入
 <!--配置Person-->
    <bean id="person" class="zlb.demo01.Person">
        <constructor-arg name="name" value="胡歌"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="computer" ref="computer"></constructor-arg>
    </bean>
      <!--配置Computer-->
    <bean id="computer" class="zlb.demo01.Computer">
        <constructor-arg name="brand" value="华硕"></constructor-arg>
        <constructor-arg name="color" value="白色"></constructor-arg>
        <constructor-arg name="price" value="6000.00"></constructor-arg>
    </bean>

测试类

//Spring整合Junit
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations ="classpath:beans.xml")
public class PersonTest {
    @Autowired
    private Person person;
    @Test
    public void  test(){

        System.out.println(person);

    }
}

Spring IOC(纯注解)

//Person类
@Component("person")
//通过内路径下的properties文件配置数据
@PropertySource("classpath:computer.properties")
public class Computer {
    @Value("${brand}")
    private  String brand;
    @Value("${color}")
    private  String color;
    @Value("${price}")
    private  Double price;
    public Computer() {
        super();
    }
    public Computer(String brand, String color, Double price) {
        this.brand = brand;
        this.color = color;
        this.price = price;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Computer{" +
                "brand='" + brand + '\'' +
                ", color='" + color + '\'' +
                ", price=" + price +
                '}';
    }



//Compuer类
@Component("computer")
@PropertySource("classpath:computer.properties")
public class Computer {
    @Value("${brand}")
    private  String brand;
    @Value("${color}")
    private  String color;
    @Value("${price}")
    private  Double price;
    public Computer() {
        super();
    }
    public Computer(String brand, String color, Double price) {
        this.brand = brand;
        this.color = color;
        this.price = price;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Computer{" +
                "brand='" + brand + '\'' +
                ", color='" + color + '\'' +
                ", price=" + price +
                '}';
    }
}

}

//配置类
/*@Configuration 表明这是一个配置类
@ComponentScan 扫描指定包下所有bean对象
* */
@Configuration
@ComponentScan(basePackages = "zlb.demo02")
public class ConfigClass {

}

person.properties文件
name=胡歌
age=18
computer。properties文件
brand=华硕
color=白色
price=5000.00

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ConfigClass.class)
public class PersonTest {
    @Autowired
    private Person person;
    @Test
    public void  test(){
        System.out.println(person);
    }
}

基于Spring IOC的增删改查

依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
    </dependencies>


/*
* 账户实体类
* */
public class Account {

    private  Integer id;
    private  String name;
    private  Double money;
    public Account() {
        super();
    }
    public Account(Integer id, String name, Double money) {
        this.name = name;
        this.id = id;
        this.money = money;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + '\'' +
                ", age=" + id+
                ", money=" + money +
                '}';
    }
}


/*
* 账户持久层接口
* */
public interface AccountDao {
    /*
    * 查询所有账户
    * */
  List<Account>  findAllAccount();

  /*根据Id查一个账户
  * */
  Account findAccountById(Integer accountId);

  //更新账户
  void updateAccount(Account account);

  /*
  * 插入新账户
  * */
  void insertAccount(Account account);

  /*
  * 根据Id删除账户
  * */
  void deleteById(Integer accountId);

}


/*
* 账户持久层实现类
* */
public class AccountDaoImpl implements AccountDao {
    
    private QueryRunner queryRunner;

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }
    public List<Account> findAllAccount() {
        try {
           return queryRunner.query("select * from account", new BeanListHandler<Account>(Account.class));
        } catch (Exception e) {
            throw  new  RuntimeException(e);
        }
    }
    public Account findAccountById(Integer accountId) {
        try {
            return queryRunner.query("select * from account where id=?", new BeanHandler<Account>(Account.class), accountId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public void updateAccount(Account account) {
        try {
            queryRunner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        } catch (Exception e) {
           throw  new RuntimeException(e);
        }
    }
    public void insertAccount(Account account) {
        try {
            queryRunner.update("insert into account (id,name,money)values(?,?,?)",account.getId(),account.getName(),account.getMoney());
        } catch (Exception e) {
            throw  new  RuntimeException(e);
        }
    }
    public void deleteById(Integer accountId) {
        try {
            queryRunner.update("delete from account where id=?",accountId);
        } catch (Exception e) {
           throw  new RuntimeException(e);
        }
    }
}



/*
* 账户业务层接口
* */
public interface AccountService {
    /*
     * 查询所有*/
    List<Account> findAllAccount();

    /*根据Id查一个
     * */
    Account findAccountById(Integer accountId);

    //更新
    void updateAccount(Account account);

    /*
     * 插入
     * */
    void insertAccount(Account account);

    /*
     * 根据Id删除
     * */
    void deleteById(Integer accountId);
}



/*
* 账户业务层实现类
* */
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }
    public void insertAccount(Account account) {
        accountDao.insertAccount(account);
    }

    public void deleteById(Integer accountId) {
        accountDao.deleteById(accountId);
    }
}

xml配置

 <!--配置业务层-->
    <bean id="accountService" class="zlb.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <!--配置持久层-->
    <bean id="accountDao" class="zlb.dao.impl.AccountDaoImpl">
       <!--注入Query-->
        <property name="queryRunner" ref="runner"></property>
    </bean>
    <!--配置Query-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner">
       <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="user" value="root"></property>
        <property name="password" value="151630"></property>
    </bean>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:beans.xml")
public class TestApp {
    @Autowired
    private AccountService accountService;
    @Test
    public void findOneById(){
        Account account = accountService.findAccountById(3);
        System.out.println(account);
    }
    @Test
    public void findAll(){
      List<Account> allAccount = accountService.findAllAccount();
        for (Account account : allAccount) {
            System.out.println(account);
        }
    }
    @Test
    public  void delete(){
        accountService.deleteById(10);
    }
    @Test
    public  void update(){
        Account account = accountService.findAccountById(3);
        account.setMoney(5000d);
        account.setName("java");
        accountService.updateAccount(account);
    }
    @Test
    public void insert(){
        accountService.insertAccount(new Account(35,"spring",6000d));
    }
}

基于Spring IOC的增删改查(全注解)

新增一个配置类其他类全用注解配置

@Configuration
@ComponentScan("zlb")
public class SpringConfiguration {

    /**
     * 创建一个数据源，并存入 spring 容器中
     */
    @Bean(name="dataSource")
    public DataSource createDataSource() {
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setUser("root");
            ds.setPassword("151630");
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/eesy");
            return ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        } }
    /**
     * 创建一个 Query，并且也存入 spring 容器中
     */
    @Bean(name="runner")
    public QueryRunner createQuery(DataSource dataSource) {
        return new QueryRunner(dataSource);
    } }

动态代理

/*
* 接口类
* */
public interface IProducer {
    //卖产品
    void saleProduct(float money);
    
    //售后服务
     void afterService(float money);
}


/*
* 实现类生产者
* */
public class Produce implements IProducer {

    public void saleProduct(float money) {
    }
    public void afterService(float money) {
        System.out.println(money);

    }
}


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Client {
    public static void main(String[] args) {
     final Produce produce=new Produce();
      
       final IProducer iProducer =(IProducer) Proxy.newProxyInstance(produce.getClass().getClassLoader(),
               produce.getClass().getInterfaces(), new InvocationHandler() {
                   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                      Object value=null;
                     Float money=(Float)args[0];
                     if ("afterService".equals(method.getName())) {
                         value = method.invoke(produce, money * 0.8f);
                     }
                     return  value;
                   }
               });
        iProducer.afterService(10000f);
    }
}

SpringAop(xml)

//被通知类
public class Phone {

    public  void  playMusic(Stirng name){
        System.out.println("正在播放音乐");

    }
}

//通知类
public class Message {
    public  void beforePrint(){
        System.out.println("正在打印前置信息");
    }
    public  void returningPrint(){

        System.out.println("正在打印返回信息");

    }
    public  void throwingPrint()
    {

        System.out.println("正在打印异常信息");

    }
    public  void afterPrint(){

        System.out.println("正在打印最终信息");

    }
    

 <!--配置被通知类-->
        <bean id="phone" class="zlb.dao.Phone"></bean>
        <!--配置通知类-->
        <bean id="message" class="zlb.Message"></bean>
       
        <!--开启AOP配置-->
        <aop:config>
         <!--配置切面点-->
         <!--说明哪个类是通知类-->
      <aop:aspect id="messageAdvice" ref="message">
      <aop:before method="beforePrint" pointcut-ref="pt"></aop:before>
      <aop:after-returning method="returningPrint" pointcut-ref="pt" ></aop:after-returning>
      <aop:after-throwing method="throwingPrint" pointcut-ref="pt"   ></aop:after-throwing>
      <aop:after method="afterPrint" pointcut-ref="pt"></aop:after>
     <!--切面表达式，建立通知类与被通知类的关系-->
      <aop:pointcut id="pt" expression="execution(* zlb.dao.*.*(..))"/>
       </aop:aspect>
        </aop:config>

环绕通知

public class Phone {

    public  String playMusic(String name){
        return  name;
    }
}


public class Message {
    public Object aroundPrint(ProceedingJoinPoint point) {
        Object value = null;
        String name = point.getSignature().getName();
        try {
            System.out.println("前置通知开始了,"+"被增强的方法名为:"+name+"参数是"+ Arrays.asList(point.getArgs()));
            Object[] args = point.getArgs();
            for (int i = 0; i < args.length; i++) {
                if (args[i].equals("江南")
                ) {
                    value = point.proceed(new Object[]{"醉赤壁"});
                }
                else {
                    value=point.proceed();
                }
        }
        System.out.println("返回通知开始了,"+"被增强的方法为:"+name+"返回结果是"+value);
            return value;

        } catch (Throwable th) {
            System.out.println("异常通知开始了,"+"被增强的方法名为:"+name+"异常为"+th);
            throw new RuntimeException(th);
        } finally {
            System.out.println("后置通知开始了,"+"方法;"+name+"结束啦");
        }


    }
}


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations ="classpath:beans.xml")
public class TestAop {
    @Autowired
    private Phone phone;
    @Test
    public  void test(){

    
        phone.playMusic("江南");
        System.out.println("============");
        phone.playMusic(null);

    }
}

在这里插入图片描述

SpringAop(全注解)

@Component("phone")
public class Phone {

    public  void playMusic(){
        System.out.println("正在播放音乐");
       
    }
}


@Component("message")
@Aspect
public class Message {
    @Pointcut("execution(* zlb.*.*(..))")
    public void pt() {
    }

      @Before("pt()")
    public  void beforePrint(){
        System.out.println("正在打印前置信息");
    }
    @After("pt()")
    public  void returningPrint(){

        System.out.println("正在打印返回信息");

    }
    @AfterThrowing("pt()")
    public  void throwingPrint()
    {

        System.out.println("正在打印异常信息");

    }
    @After("pt()")
    public  void afterPrint(){

        System.out.println("正在打印最终信息");

    }
    }
//配置类
@Configuration
@ComponentScan(basePackages = "zlb")
@EnableAspectJAutoProxy
public class ConfigClass {


}

//测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ConfigClass.class)
public class AppTest {
    @Autowired
    private Phone phone;

    @Test
    public  void test(){

       phone.playMusic();


    }
}
努力努力努力go
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring学习
12-28
在"spring学习"的过程中，你需要掌握以下几个关键知识点： 1. **依赖注入（Dependency Injection, DI）**：Spring的核心特性之一，它允许你在不创建对象的情况下控制对象间的依赖关系。通过XML配置、注解或Java配置...
spring学习视频.doc
10-10
总之，这个Spring学习视频将引导你深入理解Spring框架的各个方面，提升你的开发技能，使你能够更好地应对复杂的项目需求。通过观看并实践教程中的示例，你将对Spring有更全面、深入的认识，从而在工作中更加得心应手...
基础知识巩固之spring
Meditation_Crazy
10-09 90
前言 概念性问题，面试问题等 文章 Spring常见面试题总结（超详细回答）
Spring中的Bean
aikunjiao3421的博客
05-21 286
一、Bean的配置 1.Spring可以被看做是一个大型的工厂，这个工厂的作用就是生产和管理Spring中的Bean，要在项目中使用这个工厂，就要对Spring的配置文件进行配置。Spring支持XML和Properties两种方式的配置文件。在实际开发过程中，最常用的就是XML各式的配置，这种配置方式是通过XML文件来注册并管理Bean之间的依赖关系。 2.在Spring中，XM...
第2章 Spring中的Bean
dengpan1889的博客
05-18 102
2.1 Bean的配置 Bean本质是Java中的类。Spring可以被看做一个大型工厂，这个工厂的作用就是生产和管理Spring容器zho中的Bean。想在项目中使用这个工厂，就需要对Spring的配置文件进行配置。 Spring支持XML和Properties两种格式的配置文件。常用XML文件配置，该方式通过XML文件来注册并管理Bean之间的依赖关系。 XML配置文件的根元素...
spring 学习笔记
2301_79098873的博客
05-04 986
对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！oryBean** 会创建它自有的 MyBatis 环境配置（），并按要求设置自定义环境的值。
Spring 学习笔记
热门推荐
草原孤狼的专栏
01-07 55万+
好记忆不如烂笔头, 能记下点什么, 就记下点什么, 方便后期的巩固 Spring介绍 Spring 是一个开源框架，是一个分层的 JavaEE 一站式框架。 所谓一站式框架是指 Spring 有 JavaEE 开发的每一层解决方案。 WEB层：SpringMVC Service层：Spring的Bean管理，声明式事务 DAO层：Spring的JDBC模板，ORM模...
Spring 框架深入学习
2301_79994937的博客
07-22 262
Spring是一个分层的全栈轻量级开源框架，提供了丰富的企业级应用技术，如IoC、AOP、持久层访问（如Spring JDBC、Spring ORM）、Web层访问（如Spring MVC）等。核心组件 Spring框架主要由七大模块组成：Spring Core、Spring AOP、Spring ORM、Spring DAO、Spring Context、Spring Web和Spring Web MVC。近年来，随着Spring Boot的推出，Spring框架的易用性和开发效率得到了进一步提升。
狂神说Spring学习笔记
记录学习的历程
03-14 1113
目录P1、Spring1、简介2、优点3、组成4、拓展P2、IOC基础1、IOC理论推导2、IOC本质3、HelloSpring 本文链接： B站狂神说Spring5视频 Kuang-Study文章 P1、Spring 1、简介 Spring : 春天 —->给软件行业带来了春天 2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。 2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。 很难想象Rod J
SpringSecurity学习总结
be_ok的博客
03-20 296
学习目标： 全面掌握Spring Security各种细节 学习内容： Spring Security的默认登录页面 如何配置Spring Security sec标签的使用 文章目录学习目标：全面掌握Spring Security各种细节学习内容：前言一、Spring Security的默认登录页面二、如何配置Spring Security1.创建一个类2.授权(Authorization)3.认证(Authentication)三、sec标签的使用 前言 新手第一篇文章 这是基于狂神的Sprin
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
springcloud学习资料
07-19
Spring Cloud 是一个基于 Spring Boot 实现的云应用...你可以通过阅读文档、查看代码实例来逐步掌握这些知识点，并通过实际操作来巩固学习效果。在实践中遇到问题时，查阅官方文档、社区问答和教程都能为你提供帮助。
spring5学习笔记
11-23
阅读《Spring5框架课堂笔记.pdf》时，建议按照上述知识点进行深入学习，结合实际项目实践，以巩固理论知识。同时，不断关注Spring社区的最新动态和技术更新，保持学习的前沿性。在实践中不断提升，你将能充分利用...
2022年全国地级市人口分布数据(全新整理)
08-15
1、资源内容地址：https://blog.csdn.net/2301_79696294/article/details/140877988 2、代码特点：今年全新，手工精心整理，放心引用，数据来自权威，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 3、适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 3、课程引用，经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理 ## 数据指标说明 资源名称：2022年全国地级市人口分布数据 区域范围：全国地级市 数据格式：.shp格式 数据规模:大于2G 数据来源：https://landscan.ornl.gov/
基于SSM++jsp的共享客栈管理系统
08-15
内容概要 共享客栈管理系统基于SSM（Spring、Spring MVC、MyBatis）框架和JSP技术开发，旨在为共享经济模式下的客栈经营者提供高效、便捷的信息管理工具。该系统集成了客栈房间管理、预订管理、入住与退房管理、账单管理以及客户信息管理等核心功能，帮助经营者全面掌控客栈的运营情况。系统支持实时更新客栈的房间状态，并能自动生成统计报表，方便经营者分析运营数据，提升管理效率。同时，系统具备多用户角色管理功能，支持不同权限的用户进行相应的操作，从而保障数据的安全性。 适用人群 本系统主要面向共享客栈经营者、房东、民宿管理公司以及IT技术人员。对于经营者和房东，系统提供了全方位的客栈管理功能，可以有效减少手工管理的工作量，提高运营效率。民宿管理公司可以利用该系统管理旗下多个客栈的日常运营情况，实现集中化管理。而IT技术人员则可以根据系统的架构，进行定制开发，满足特定客栈的个性化需求。此外，该系统也适用于需要系统化管理住宿资源的其他类似小型住宿业者。 使用场景及目标 该系统适用于多种场景，包括客栈日常的房间预订与管理、客户信息记录、账单生成及分析等。在实际使用中，经营者可以通过
JSP-个性化点餐配送系统（源码+数据库+论文）.rar
最新发布
08-15
互联网系统平台的广泛应用，改变了人们生活方式的同时也优化提升了人们的生活质量，利用线上系统平台可以实现更加便捷高效的信息获取及在线操作，线上点餐系统的不断普及，让人们体验到了足不出户的点餐服务，利用线上平台信息互通的便捷性实现了商家、客户以及配送员的三方信息互通，借助点餐系统平台可以实现菜品订单信息的添加、在线下单及支付操作以及订单配送员调配。随着餐饮行业的竞争日益激烈，线下的经营模式已经无法满足很多餐厅的经营需求，借助线上系统平台不仅能够拓宽经营渠道同时也为传统的餐饮门店吸引了更多潜在客户。 结合当前餐饮行业的发展现状，本文借助SSM框架实现了点餐配送系统平台的搭建，结合主要用户角色客户、商家、配送员以及系统管理员的功能需求，通过JSP技术的应用实现了前后端的信息共享和动态页面内容呈现，借助点餐配送系统的开发实现了菜品信息管理、客户订单管理、商家配送管理等功能模块的运行，通过点餐配送系统平台的搭建实现了从菜品管理到终端配送的一系列服务内容，结合网络在线订餐系统的发展趋势，优化提升力了点餐的效率及满足更多用户的用餐需求。 关键词：SSM框架；JSP技术；MySQL数据库；点餐配送
YOLO 目标检测图像数据集：施工电缆缺陷检测
08-15
YOLO 目标检测图像数据集：施工电缆缺陷检测【包含训练集、验证集、对应标签、class文件】 数据集被处理成yolo格式，可以用于YOLO所有系列的网络训练。show脚本可以用于可视化数据，即将box目标绘制在图像上 类别个数（2）：break等等【具体类别参考class类别文本文件】超过1000张数据和标签文件
spring学习路线
08-05
对于初学者来说，学习Spring框架可以按照以下路线进行： 1. Java基础知识：在学习Spring之前，建议先掌握Java的基础知识，包括面向对象编程、集合框架、异常处理等内容。 2. IoC和DI概念：Spring框架的核心思想是控制反转（IoC）和依赖注入（DI），要先理解这两个概念。可以通过阅读相关的资料、教程或者视频来学习。 3. Spring核心模块：了解Spring框架的核心模块，包括Spring Core、Spring Context和Spring Beans。这些模块提供了IoC容器、Bean管理和依赖注入等功能。 4. Spring AOP：学习Spring的面向切面编程（AOP）模块，掌握如何使用AOP实现日志记录、事务管理等功能。 5. Spring MVC：学习Spring MVC模块，了解如何构建基于MVC（Model-View-Controller）的Web应用程序。学习控制器、视图解析器、数据绑定等相关知识。 6. 数据访问：学习Spring框架提供的数据访问模块，包括Spring JDBC、Spring ORM和Spring Data等。了解如何与数据库进行交互和操作。 7. 整合其他技术：学习如何将Spring框架与其他技术进行整合，例如与Hibernate、MyBatis、Spring Boot等框架的整合。 8. 实践项目：通过实践项目来巩固所学的知识，可以选择一个简单的项目进行实践，逐步提升自己的技能。 此外，还可以参加一些相关的培训课程、线上教育平台或者加入开发者社区，与其他开发者交流和学习经验。不断实践和积累经验是提高技能的关键。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值