springBoot进阶02

SpringBoot进阶02

1. 日志的使用

1.1 基本使用

/**
 * 获取日志记录器
 */
Logger logger = LoggerFactory.getLogger(this.getClass());

@RequestMapping("/hello")
@ResponseBody
public String sayHello(){
    //日志级别 trace<debug<info<warn<error
    logger.trace("trace....");
    logger.debug("debug....");
    logger.info("info....");
    logger.warn("warn....");
    logger.error("error...");
    return "hello springBoot!";
}

基本使用

1.2 yml修改日志级别

在application.yml中(指定到修改的包)

#修改日志级别(默认是info) trace<debug<info<warn<error
logging:
  level:
   cn:
     dyier: trace

1.3 指定配置文件配置logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
scan:当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。
scanPeriod:设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒当scan为true时,此属性生效。默认的时间间隔为1分钟。
debug:当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。
-->
<configuration scan="false" scanPeriod="60 seconds" debug="false">
    <!-- 定义日志的根目录 -->
    <property name="LOG_HOME" value="E:/springbootLogs" />
    <!-- 定义日志文件名称 -->
    <property name="appName" value="dyier-springboot"/>
    <!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--
        日志输出格式:
         %d表示日期时间,
         %thread表示线程名,
         %-5level:级别从左显示5个字符宽度
         %logger{50} 表示logger名字最长50个字符,否则按照句点分割。
         %msg:日志消息,
         %n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </layout>
    </appender>

    <!-- 滚动记录文件,先将日志记录到指定文件,当符合某个条件时,将日志记录到其他文件 -->
    <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 指定日志文件的名称 -->
        <file>${LOG_HOME}/${appName}.log</file>
        <!--
        当发生滚动时,决定 RollingFileAppender 的行为,涉及文件移动和重命名
        TimeBasedRollingPolicy: 最常用的滚动策略,它根据时间来制定滚动策略,既负责滚动也负责出发滚动。
        -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--
            滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}:按天进行日志滚动
            %i:当文件大小超过maxFileSize时,按照i进行文件滚动
            -->
            <fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!--
            可选节点,控制保留的归档文件的最大数量,超出数量就删除旧文件。假设设置每天滚动,
            且maxHistory是365,则只保存最近365天的文件,删除之前的旧文件。注意,删除旧文件是,
            那些为了归档而创建的目录也会被删除。
            -->
            <MaxHistory>365</MaxHistory>
            <!--
            当日志文件超过maxFileSize指定的大小是,根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的,必须配置timeBasedFileNamingAndTriggeringPolicy
            -->
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <!-- 日志输出格式: -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern>
        </layout>
    </appender>

    <!--
      logger主要用于存放日志对象,也可以定义日志类型、级别
      name:表示匹配的logger类型前缀,也就是包的前半部分
      level:要记录的日志级别,包括 TRACE < DEBUG < INFO < WARN < ERROR
      additivity:作用在于children-logger是否使用 rootLogger配置的appender进行输出,
      false:表示只用当前logger的appender-ref,true:
      表示当前logger的appender-ref和rootLogger的appender-ref都有效
    -->
    <!-- hibernate logger -->
    <logger name="cn.dyier" level="debug" />
    <!-- Spring framework logger -->
    <logger name="org.springframework" level="debug" additivity="false"/>

    <!--
    root与logger是父子关系,没有特别定义则默认为root,任何一个类只会和一个logger对应,
    要么是定义的logger,要么是root,判断的关键在于找到这个logger,然后判断这个logger的appender和level。
    -->
    <root level="info">
        <appender-ref ref="stdout" />
        <appender-ref ref="appLogAppender" />
    </root>
</configuration>

logback.xml

1.4 指定配置文件配置logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
scan:当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。
scanPeriod:设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒当scan为true时,此属性生效。默认的时间间隔为1分钟。
debug:当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。
-->
<configuration scan="false" scanPeriod="60 seconds" debug="false">
    <!-- 定义日志的根目录 -->
    <property name="LOG_HOME" value="E:/logback-spring" />
    <!-- 定义日志文件名称 -->
    <property name="appName" value="dyier-springboot"/>
    <!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--
        日志输出格式:
         %d表示日期时间,
         %thread表示线程名,
         %-5level:级别从左显示5个字符宽度
         %logger{50} 表示logger名字最长50个字符,否则按照句点分割。
         %msg:日志消息,
         %n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <springProfile name="dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
            <springProfile name="!dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
        </layout>
    </appender>

    <!-- 滚动记录文件,先将日志记录到指定文件,当符合某个条件时,将日志记录到其他文件 -->
    <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 指定日志文件的名称 -->
        <file>${LOG_HOME}/${appName}.log</file>
        <!--
        当发生滚动时,决定 RollingFileAppender 的行为,涉及文件移动和重命名
        TimeBasedRollingPolicy: 最常用的滚动策略,它根据时间来制定滚动策略,既负责滚动也负责出发滚动。
        -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--
            滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}:按天进行日志滚动
            %i:当文件大小超过maxFileSize时,按照i进行文件滚动
            -->
            <fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!--
            可选节点,控制保留的归档文件的最大数量,超出数量就删除旧文件。假设设置每天滚动,
            且maxHistory是365,则只保存最近365天的文件,删除之前的旧文件。注意,删除旧文件是,
            那些为了归档而创建的目录也会被删除。
            -->
            <MaxHistory>365</MaxHistory>
            <!--
            当日志文件超过maxFileSize指定的大小是,根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的,必须配置timeBasedFileNamingAndTriggeringPolicy
            -->
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <!-- 日志输出格式: -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern>
        </layout>
    </appender>

    <!--
      logger主要用于存放日志对象,也可以定义日志类型、级别
      name:表示匹配的logger类型前缀,也就是包的前半部分
      level:要记录的日志级别,包括 TRACE < DEBUG < INFO < WARN < ERROR
      additivity:作用在于children-logger是否使用 rootLogger配置的appender进行输出,
      false:表示只用当前logger的appender-ref,true:
      表示当前logger的appender-ref和rootLogger的appender-ref都有效
    -->
    <!-- hibernate logger -->
    <logger name="cn.dyier" level="info" />
    <!-- Spring framework logger -->
    <logger name="org.springframework" level="debug" additivity="false"/>

    <!--
    root与logger是父子关系,没有特别定义则默认为root,任何一个类只会和一个logger对应,
    要么是定义的logger,要么是root,判断的关键在于找到这个logger,然后判断这个logger的appender和level。
    -->
    <root level="info">
        <appender-ref ref="stdout" />
        <appender-ref ref="appLogAppender" />
    </root>
</configuration>

logback-spring.xml

1.5 logback.xml与logback-spring的区别

logback.xml:直接就被日志框架识别了

logback-spring.xml:日志框架就不直接加载日志的配置项,由SpringBoot解析日志配置,可以使用SpringBoot的高级Profile功能

1.6 配置文件指定日志写入磁盘的方式

方式一:

logging.file: E:/logback/logs

方式二:

logging.path: E:/logback/logs

1.7 切换日志框架为log4j2

pox.xml取消logback依赖,引入log4j2依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
<!--                排除logback-->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
<!--        引入log4j2-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

依赖

1.8 编写log4j2-spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status,这个用于设置log4j2自身内部的信息输出,可以不设置,当设置成trace时,你会看到log4j2内部各种详细输出-->
<!--monitorInterval:Log4j能够自动检测修改配置 文件和重新配置本身,设置间隔秒数-->
<configuration status="WARN" monitorInterval="30">
    <!--先定义所有的appender-->
    <appenders>
        <!--这个输出控制台的配置-->
        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
        </console>
        <!--文件会打印出所有信息,这个log每次运行程序会自动清空,由append属性决定,这个也挺有用的,适合临时测试用-->
        <File name="log" fileName="log/test.log" append="false">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>
        <!-- 这个会打印出所有的info及以下级别的信息,每次大小超过size,则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩,作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${sys:user.home}/logs/info.log"
                     filePattern="${sys:user.home}/logs/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch)-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 MB"/>
            </Policies>
        </RollingFile>
        <RollingFile name="RollingFileWarn" fileName="${sys:user.home}/logs/warn.log"
                     filePattern="${sys:user.home}/logs/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置,则默认为最多同一文件夹下7个文件,这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>
        <RollingFile name="RollingFileError" fileName="${sys:user.home}/logs/error.log"
                     filePattern="${sys:user.home}/logs/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log">
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 MB"/>
            </Policies>
        </RollingFile>
    </appenders>
    <!--然后定义logger,只有定义了logger并引入的appender,appender才会生效-->
    <loggers>
        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <logger name="org.springframework" level="INFO"/>
        <logger name="org.mybatis" level="INFO"/>
        <root level="all">
            <appender-ref ref="Console"/>
            <appender-ref ref="log"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>
</configuration>

log4j2-spring

2. SpringBoot继承Thymeleaf

2.1 导入依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

2.2 创建模板hello.html(文件位置:classpath:templates/hello.html)

<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>成功!</h1>
    <!--使用语法th:text 将div里面的文本内容设置为 -->

    <div th:text="${msg}">这是显示欢迎信息</div>
</body>
</html>

2.3 编写controller

@RequestMapping("/jsp")
public String jsp(Model model) {
    model.addAttribute("msg", "hello jsp");
    //会去找classpath:templates/hello.html
    return "hello";
}

2.4 Thymeleaf的自动配置原理

@EnableAutoConfiguration 开启自动配置功能,通过一个AutoConfigurationImportSelector导入选择器去扫描 spring-boot-autoconfigure-2.0.5.RELEASE.jar 自动配置包下面的 spring.factories 文件中的很多很多的自动配置的类

而:ThymeleafAutoConfiguration 是的Thymeleaf的自动配置 ,在这个自动配置类里面通过一个ThymeleafProperties去读取配置文件中的配置(也有默认配置) ,来自动配置Thymeleaf,比如Thymeleaf的视图解析器的自动配置如下:

@Bean

@ConditionalOnMissingBean(name = "thymeleafViewResolver")

public ThymeleafViewResolver thymeleafViewResolver() {

ThymeleafViewResolver resolver = new ThymeleafViewResolver();

...

return resolver;

}

3. 静态资源

3.1 静态资源目录

Classpath:/static(resources/static)

3.2 webjars

导入依赖

<dependency>
    <groupId>org.webjars.bower</groupId>
    <artifactId>jquery</artifactId>
    <version>3.3.1</version>
</dependency>

3.3 模板导入jquery的js

<script th:src="@{/webjars/jquery/3.3.1/dist/jquery.js}"></script>

3.4 配置首页

classpath:/index.html(resources/index.html)

3.5 网站图标

classpath:/favicon.icon(resources/favicon.icon)

4. SpringBoot中的MVC配置

4.1 配置拦截器

定义拦截器

@Configuration
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("前置拦截");
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("后置拦截");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

4.2 注册拦截器和添加视图控制器

@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {
    @Autowired
    private LoginInterceptor loginInterceptor;

    /**
     * 批量注册拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor).addPathPatterns("/**")
                .excludePathPatterns("/json02/obj");
    }

    /**
     * 批量注册ViewController
     * @param registry
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/hello").setViewName("hello");
    }
}

5. 集成DataSource

5.1 导入依赖

<!-- mysql 数据库驱动. -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
<!--        mybatis基于jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

5.2 配置文件自动配置datasource

spring:
  #配置spring DataSource
  datasource:
    url: jdbc:mysql:///test
    username: root
    password: 123456

6. 继承Mybatis

6.1 导入依赖

<!--
            spring-boot mybatis依赖:

            请不要使用1.0.0版本,因为还不支持拦截器插件,
            1.1.1 是博主写帖子时候的版本,大家使用最新版本即可
         -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency

6.2 配置Mybatis包代理(application.yml)

#mybaits包代理
mybatis:
  type-aliases-package: cn.dyier.domain, cn.dyier.query

6.3 配置Mapper接口扫描包(@MapperScan)

@MapperScan
@SpringBootApplication
@MapperScan("cn.dyier.mapper")
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

7. 集成事务

7.1 service上直接打标签

springBoot自动配置类事务。直接打标签即可

@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    @Override
    @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
    public void save(User user) {
        userMapper.save(user);
    }

    @Override
    public List<User> findAll() {
        PageHelper.startPage(1, 3);
        return userMapper.findAll();
    }
}

8. PageHelper的使用(分页插件)

8.1 导入依赖

<!--
   MyBatis提供了拦截器接口,我们可以实现自己的拦截器,
   将其作为一个plugin装入到SqlSessionFactory中。
Github上有位开发者写了一个分页插件,我觉得使用起来还可以,挺方便的。
Github项目地址: https://github.com/pagehelper/Mybatis-PageHelper
   -->
      <dependency>
          <groupId>com.github.pagehelper</groupId>
          <artifactId>pagehelper</artifactId>
          <version>4.1.0</version>
      </dependency>

8.2 配置

@Configuration
public class MyBatisConfiguration {

@Bean
    public PageHelper pageHelper() {
System.out.println("MyBatisConfiguration.pageHelper()");
        PageHelper pageHelper = new PageHelper();
        Properties p = new Properties();
        p.setProperty("offsetAsPageNum", "true");
        p.setProperty("rowBoundsWithCount", "true");
        p.setProperty("reasonable", "true");
        pageHelper.setProperties(p);
        return pageHelper;
    }
}

8.3 使用

@Override
public List<User> findAll() {
    PageHelper.startPage(1, 3);
    return userMapper.findAll();
}

原文地址:https://www.cnblogs.com/dyier/p/12285593.html

时间: 2024-10-15 17:05:23

springBoot进阶02的相关文章

大数据学习之Linux进阶02

大数据学习之Linux进阶 1-> 配置IP 1)修改配置文件 vi /sysconfig/network-scripts/ifcfg-eno16777736 2)注释掉dhcp #BOOTPROTO="dhcp" 3)添加配置(windows->ipconfig -all) IPADDR=192.168.50.179 NETMASK=225.255.255.0 GATEWAY=192.168.50.1 DNS1=219.141.136.10 4)重启网卡 service

SpringBoot进阶教程(六十二)整合Kafka

在上一篇文章<Linux安装Kafka>中,已经介绍了如何在Linux安装Kafka,以及Kafka的启动/关闭和创建发话题并产生消息和消费消息.这篇文章就介绍介绍SpringBoot整合Kafka. v创建项目 若是已有的项目中添加kafka, 请直接跳至1.3 1.1 创建springboot: 1.2 选web和kafka: 1.3 已有的项目中添加kafka, pom.xml中添加依赖 <dependency> <groupId>org.springframew

SpringBoot进阶

表单验证 AOP处理请求 AOP是一种编程范式.与语言无关,是一种程序设计思想. 面向过程到面向对象.换个角度看世界,换个姿势处理问题. 统一异常处理 单元测试

IOS UI进阶02

01-pickerView简单使用 一.UIPickerViewDataSource // 返回有多少列 - (NSInteger)numberOfComponentsInPickerView:(UIPickerView *)pickerView; // 返回第component有多少行 - (NSInteger)pickerView:(UIPickerView *)pickerView numberOfRowsInComponent:(NSInteger)component; 二.UIPick

面向对象基础进阶02

一:面向对象的三大特征 封装,继承,多态 封装 1:封装的概念及作用      *通过使用private和public修饰符来修饰类的成员(字段,属性,方法等)这样有效的使私有数据和方法不被外界访问,这种使用特性就是封装:      *一个属性,一个方法也是封装,类是对属性和方法的封装:      *封装是面向对象中的一个重要特征,面向对象的三个重要特征为:封装,继承,多态:      *作用<模块化和数据隐藏> 2:类是模版,确定的对象将会拥有的特征(属性)和行为(方法):任何对象将会属于一

Python进阶02 文本文件的输入输出

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! Python具有基本的文本文件读写功能.Python的标准库提供有更丰富的读写功能. 文本文件的读写主要通过open()所构建的文件对象来实现. 创建文件对象 我们打开一个文件,并使用一个对象来表示该文件: f = open(文件名,模式) 最常用的模式有: "r"     # 只读 "w"     # 写入 比如 >>>f = o

4.sql进阶02(知识点)

条件表达是里面,可以使用一个只有一行一列的查询作为判断的一个根据 IF( (SELECT COUNT(id) FROM dbo.Student) >10) BEGIN PRINT '好多人啊' END ELSE begin PRINT '人好少啊' END ? ? 输出参数 ALTER PROC usp_GetStu @iid INT = 2,--有默认值的参数可以不传 @name nvarchar(10), --对于没有写默认值的参数,在调用的时候必须传递参数, --在存储过程的参数被定义的时

Java进阶02 异常处理

程序很难做到完美,不免有各种各样的异常.比 如程序本身有bug,比如程序打印时打印机没有纸了,比如内存不足.为了解决这些异常,我们需要知道异常发生的原因.对于一些常见的异常,我们还可以提供 一定的应对预案.C语言中的异常处理是简单的通过函数返回值来实现的,但返回值代表的含义往往是由惯例决定的.程序员需要查询大量的资料,才可能找到一个 模糊的原因.面向对象语言,比如C++, Java, Python往往有更加复杂的异常处理机制.这里讨论Java中的异常处理机制. Java异常处理 异常处理 Jav

Python 进阶02 文本文件的输入输出

Python 具有基本的文本文件读写功能,Python的标准库提供有更丰富的读写功能. 文本文件的读写主要通过open()所构建的文件对象来实现 创建文件对象 我们打开一个文件,并适用一个对象来表示该文件: f = open(文件名,模式) 最常用的模式有: "r"   # 只读 "w"  # 写入 比如 >>>f = open("test.txt","r") 文件对象的方法 读取: content = f.