nullablejava

❶ java.lang.ClassCastException异常

news=(News)sess.load(News.class, "0001");
问题出在这个语句，先不要强制转换，看看是什么对象。
Object obj =sess.load(News.class, "0001");
System.out.println( obj );

看看打印出来的结果是什么，然后反思一下，看是哪里出现了问题。

❷ java内存溢出

使用Java程序从数据库中查询大量的数据时出现异常:java.lang.OutOfMemoryError: Java heap space
在JVM中如果98%的时间是用于GC且可用的 Heap size 不足2%的时候将抛出此异常信息。

JVM堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设置Heap size的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可进行设置。
例如：java -jar -Xmn16m -Xms64m -Xmx128m MyApp.jar
如果Heap Size设置偏小，除了这些异常信息外，还会发现程序的响应速度变慢了。GC占用了更多的时间，而应用分配到的执行时间较少。
Heap Size 最大不要超过可用物理内存的80%，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。
Heap size的 -Xms -Xmn 设置不要超出物理内存的大小。否则会提示“Error occurred ring initialization of VM Could not reserve enough space for object heap”。

这个问题的根源是jvm虚拟机的默认Heap大小是64M,可以通过设置其最大和最小值来实现.设置的方法主要是几个.

1.可以在windows 更改系统环境变量加上JAVA_OPTS=-Xms64m -Xmx512m

2,如果用的tomcat,在windows下,可以在C:\tomcat5.5.9\bin\catalina.bat 中加上:
set JAVA_OPTS=-Xms64m -Xmx256m
位置在: rem Guess CATALINA_HOME if not defined 这行的下面加合适.

3.如果是linux系统
Linux 在{tomcat_home}/bin/catalina.sh的前面，加 set JAVA_OPTS='-Xms64 -Xmx512'

❸ java异常 救命啊

java.lang.ClassCastException: org.hibernate.lob.SerializableBlob cannot be cast to java.lang.String
从第一句可以知道，这是Hibernate类型转化的错误。
你贴这么少的代码，谁也救不了你。
不过应该是Hibernate对应数据库表的映射文件的字段类型的问题。

❹ JAVA导入向导里面是空的

首先检查环境变量是否出现问题。
if obj 等等于null来对所有需要用到的对象来进行检测，包括函数参数，返回值，以及类实例的成员变量，当你检测到 null 值时，可以选择抛出更具针对性的异常类型，如 IllegalArgumentException，并添加消息内容，我们可以使用一些库函数来简化代码。
Java 语言有许多静态代码分析工具，如EclipseIDE，SpotBugs，Checker Framework 等，它们可以帮助程序员检测出编译期的错误，结合 @Nullable 和 @Nonnull 等注解，我们就可以在程序运行之前发现可能抛出空指针异常的代码。

❺ java有什么注解前置前拦截

本文将用简洁的代码构建一个springboot的拦截器。拦截器的使用很简单，定义一个自己的拦截器，向配置中添加一下就可以使用。为了方便，之后又引入了注解。

目录和概述

概述

假设需求：访问项目的controller是都要进行"token验证"，除了某些像登录之类的方法。

项目结构：

TokenInterceptor.java 自定义拦截器

InterceptorConfig.java 添加拦截器进入项目

NoNeedToken.java 自定义注解

TestController.java 测试接口

1、自定义拦截器

在 TokenInterceptor.java 中输入以下代码，以下的代码将生成一个在请求到达controller前进行拦截的拦截器

import com.alibaba.fastjson.JSONObject;

import org.springframework.lang.Nullable;

import org.springframework.stereotype.Component;

import org.springframework.web.servlet.HandlerInterceptor;

import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.PrintWriter;

import java.util.Arrays;

import java.util.List;

@Component

public class TokenInterceptor implements HandlerInterceptor {undefined

// 假设现在的token有如下数据

List tokenList = Arrays.asList("111", "222", "333");

// 这个方法是在访问接口之前执行的，我们只需要在这里写验证登陆状态的业务逻辑，就可以在用户调用指定接口之前验证登陆状态了

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {undefined

// 设置返回为json格式，使用UTF-8

response.setCharacterEncoding("UTF-8");

response.setContentType("application/json; charset=utf-8");

String token = request.getHeader("token");

PrintWriter out;

// 之后写你的判断逻辑：return true是通过拦截器，可以继续访问controller，return false是不通过

if (token == null || !tokenList.contains(token)) {undefined

// 如果失败了返回{state:"false", msg:"token is null or wrong"}

JSONObject res = new JSONObject();

res.put("state","false");

res.put("msg","token is null or wrong");

out = response.getWriter();

out.append(res.toString());

return false;

}

// 否则返回true 进入controller

return true;

}

public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {undefined

}

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

}

}

————————————————

版权声明：本文为CSDN博主“魔王别嚣张”的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/weixin_36481714/article/details/114888055

❻ 请教，java源代码中 Override，Nullable 什么意思，小弟我从网

@Override 重载

@Nullable 参数可为null
@Nullable是用户自定义的注解，具体什么含义还要看情况，一般情况下这种Nullable用来实现null object模式

❼ java.lang.ClassCastException: java.lang.Float

原因很明显
java.lang.ClassCastException: java.lang.Float
at org.hibernate.type.IntegerType.set(IntegerType.java:41)
本身是Integer的类型，你传的是float，当然要报错了

更深层次的原因
查看你的数据库表项目的类型，查看hibernate配置文件中配置的
这个项目的类型
查看你的数据，为什么是float

❽ 怎么用java新建一个数据库表！用java语言

就是JPA是吧,你要在数据库里新建一个数据库,然后在属性文件里配置连接参数,前期工作做好了,这里我贴出我以前项目代码给你看,服务器一运行就会自动创建表的.
//////////////////////////////////////////////////////////////////////////
//
// Copyright 2010 Ningbo Safe Software Co.Ltd, All Right reserved.
//
//////////////////////////////////////////////////////////////////////////

package cn.credit.bean.information.cases;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

//************************************************************************
/**
* 系统名 : 信用物流系统平台 模块名 : 资讯系统 功能名 : 成功案例
*
* @author meiwx
* @version 1.0 Aug 13, 2010 作成
*
*/
// ************************************************************************
@Entity
@Table(name = "TAB_CASES")
public class Cases implements Serializable {

private static final long serialVersionUID = 1L;
/* 审核员 */
private String assessor;
/* 状态 */
private String status;
/* 编码 */
private String id;
/* 标题 */
private String title;
/* 内容 */
private String content;
/* 分类 */
private String sort;
/* 作者 */
private String author;
/* 删除区分 */
private char del_flg;
/* 登录时间 */
private Date insert_time;
/* 更新时间 */
private Date update_time;
/* 录入员 */
private String update_user;
/* 发布时间 */
private Date issue_time;

/**
*
*
* @return
*/
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "ISSUE_TIME", length = 20)
public Date getIssue_time() {
return issue_time;
}

public void setIssue_time(Date issue_time) {
this.issue_time = issue_time;
}

/**
*
* @return String
*/
@Id
@Column(name = "ID", length = 10, nullable = false)
public String getId() {
return id;
}

/**
*
* @param id
*/
public void setId(String id) {
this.id = id;
}

/**
*
* @return
*/
@Column(name = "STATUS", length = 1, nullable = false)
public String getStatus() {
return status;
}

/**
*
* @return
*/
@Column(name = "TITLE", length = 20)
public String getTitle() {
return title;
}

/**
*
* @param title
*/
public void setTitle(String title) {
this.title = title;
}

/**
*
* @return
*/
@Column(name = "CONTENT", length = 21000)
public String getContent() {
return content;
}

/**
*
* @param content
*/
public void setContent(String content) {
this.content = content;
}

/**
*
* @return
*/
@Column(name = "SORT", nullable = false, length = 1)
public String getSort() {
return sort;
}

/**
*
* @param sort
*/
public void setSort(String sort) {
this.sort = sort;
}

/**
*
* @return String
*/
@Column(name = "AUTHOR", length = 10)
public String getAuthor() {
return author;
}

/**
*
*/
@Column(name = "ASSESSOR")
public String getAssessor() {
return assessor;
}

public void setAssessor(String assessor) {
this.assessor = assessor;
}

public void setStatus(String status) {
this.status = status;
}

/**
*
* @param author
*/
public void setAuthor(String author) {
this.author = author;
}

/**
*
* @return
*/
@Column(name = "DEL_FLG", length = 1)
public char getDel_flg() {
return del_flg;
}

public void setDel_flg(char del_flg) {
this.del_flg = del_flg;
}

/**
*
* @return
*/
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "INSERT_TIME", nullable = false)
public Date getInsert_time() {
return insert_time;
}

/**
*
* @param insert_time
*/
public void setInsert_time(Date insert_time) {
this.insert_time = insert_time;
}

/**
*
* @return
*/
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "UPDATE_TIME", nullable = false)
public Date getUpdate_time() {
return update_time;
}

/**
*
* @param update_time
*/
public void setUpdate_time(Date update_time) {
this.update_time = update_time;
}

@Column(name = "UPDATE_USER", nullable = false)
public String getUpdate_user() {
return update_user;
}

public void setUpdate_user(String update_user) {
this.update_user = update_user;
}

}

❾ java中的空指针异常怎么解决

原文：https://www.hu.com/question

你这个问题的解决

问题定位：

在堆栈异常信息的第一行就可以定位到是哪里出了空指针，倘若这里不是你写的类，可以往下翻一下，找到你写的类，就是这里出现的空指针。

问题解决：

对一个空对象调用里面的方法或者属性的时候会报空指针，检查这个对象为什么是空即可。

Java 空指针异常的若干解决方案

Java 中任何对象都有可能为空，当我们调用空对象的方法时就会抛出 NullPointerException 空指针异常，这是一种非常常见的错误类型。我们可以使用若干种方法来避免产生这类异常，使得我们的代码更为健壮。本文将列举这些解决方案，包括传统的空值检测、编程规范、以及使用现代 Java 语言引入的各类工具来作为辅助。

运行时检测

最显而易见的方法就是使用 if (obj == null) 来对所有需要用到的对象来进行检测，包括函数参数、返回值、以及类实例的成员变量。当你检测到 null 值时，可以选择抛出更具针对性的异常类型，如 IllegalArgumentException，并添加消息内容。我们可以使用一些库函数来简化代码，如 Java 7 开始提供的 Objects#requireNonNull 方法：

public void testObjects(Object arg) {
Object checked = Objects.requireNonNull(arg, "arg must not be null");
checked.toString();}

Guava 的 Preconditions 类中也提供了一系列用于检测参数合法性的工具函数，其中就包含空值检测：

public void testGuava(Object arg) {
Object checked = Preconditions.checkNotNull(arg, "%s must not be null", "arg");
checked.toString();
}

我们还可以使用 Lombok 来生成空值检测代码，并抛出带有提示信息的空指针异常：

public void testLombok(@NonNull Object arg) {
arg.toString();

生成的代码如下：

public void testLombokGenerated(Object arg) {
if (arg == null) {
throw new NullPointerException("arg is marked @NonNull but is null");
}
arg.toString();
}

这个注解还可以用在类实例的成员变量上，所有的赋值操作会自动进行空值检测。

编程规范

·通过遵守某些编程规范，也可以从一定程度上减少空指针异常的发生。

使用那些已经对 null 值做过判断的方法，如 String#equals、String#valueOf、以及三方库中用来判断字符串和集合是否为空的函数：

if (str != null && str.equals("text")) {}
if ("text".equals(str)) {}

if (obj != null) { obj.toString(); }
String.valueOf(obj); // "null"

// from spring-core
StringUtils.isEmpty(str);
CollectionUtils.isEmpty(col);
// from guava
Strings.isNullOrEmpty(str);
// from commons-collections4
CollectionUtils.isEmpty(col);

·如果函数的某个参数可以接收 null 值，考虑改写成两个函数，使用不同的函数签名，这样就可以强制要求每个参数都不为空了：

public void methodA(Object arg1) {
methodB(arg1, new Object[0]);
}

public void methodB(Object arg1, Object[] arg2) {
for (Object obj : arg2) {} // no null check
}

·如果函数的返回值是集合类型，当结果为空时，不要返回 null 值，而是返回一个空的集合；如果返回值类型是对象，则可以选择抛出异常。Spring JdbcTemplate 正是使用了这种处理方式：

// 当查询结果为空时，返回 new ArrayList<>()
jdbcTemplate.queryForList("SELECT * FROM person");

// 若找不到该条记录，则抛出
jdbcTemplate.queryForObject("SELECT age FROM person WHERE id = 1", Integer.class);

// 支持泛型集合
public <T> List<T> testReturnCollection() {
return Collections.emptyList();
}

静态代码分析

Java 语言有许多静态代码分析工具，如 Eclipse IDE、SpotBugs、Checker Framework 等，它们可以帮助程序员检测出编译期的错误。结合 @Nullable 和 @Nonnull 等注解，我们就可以在程序运行之前发现可能抛出空指针异常的代码。

但是，空值检测注解还没有得到标准化。虽然 2006 年 9 月社区提出了 JSR 305 规范，但它长期处于搁置状态。很多第三方库提供了类似的注解，且得到了不同工具的支持，其中使用较多的有：

• javax.annotation.Nonnull：由 JSR 305 提出，其参考实现为 com.google.code.findbugs.jsr305；

• org.eclipse.jdt.annotation.NonNull：Eclipse IDE 原生支持的空值检测注解；

• e.umd.cs.findbugs.annotations.NonNull：SpotBugs 使用的注解，基于 findbugs.jsr305；

• org.springframework.lang.NonNull：Spring Framework 5.0 开始提供；

• org.checkerframework.checker.nullness.qual.NonNull：Checker Framework 使用；

• android.support.annotation.NonNull：集成在安卓开发工具中；

我建议使用一种跨 IDE 的解决方案，如 SpotBugs 或 Checker Framework，它们都能和 Maven 结合得很好。

SpotBugs 与 @NonNull、@CheckForNull

SpotBugs 是 FindBugs 的后继者。通过在方法的参数和返回值上添加 @NonNull 和 @CheckForNull 注解，SpotBugs 可以帮助我们进行编译期的空值检测。需要注意的是，SpotBugs 不支持 @Nullable 注解，必须用 @CheckForNull 代替。如官方文档中所说，仅当需要覆盖 @ParametersAreNonnullByDefault 时才会用到 @Nullable。

官方文档 中说明了如何将 SpotBugs 应用到 Maven 和 Eclipse 中去。我们还需要将 spotbugs-annotations 加入到项目依赖中，以便使用对应的注解。

• <dependency>


• <groupId>com.github.spotbugs</groupId>


• <artifactId>spotbugs-annotations</artifactId>


• <version>3.1.7</version>


• </dependency>



以下是对不同使用场景的说明：

• @NonNull


• private Object returnNonNull() {


• // 错误：returnNonNull() 可能返回空值，但其已声明为 @Nonnull


• return null;


• }



• @CheckForNull


• private Object returnNullable() {


• return null;


• }



• public void testReturnNullable() {


• Object obj = returnNullable();


• // 错误：方法的返回值可能为空


• System.out.println(obj.toString());


• }



• private void argumentNonNull(@NonNull Object arg) {


• System.out.println(arg.toString());


• }



• public void testArgumentNonNull() {


• // 错误：不能将 null 传递给非空参数


• argumentNonNull(null);


• }



• public void testNullableArgument(@CheckForNull Object arg) {


• // 错误：参数可能为空


• System.out.println(arg.toString());


• }



对于 Eclipse 用户，还可以使用 IDE 内置的空值检测工具，只需将默认的注解 org.eclipse.jdt.annotation.Nullable 替换为 SpotBugs 的注解即可：



Checker Framework 与 @NonNull、@Nullable

Checker Framework 能够作为 javac 编译器的插件运行，对代码中的数据类型进行检测，预防各类问题。我们可以参照 官方文档，将 Checker Framework 与 maven-compiler-plugin 结合，之后每次执行 mvn compile 时就会进行检查。Checker Framework 的空值检测程序支持几乎所有的注解，包括 JSR 305、Eclipse、甚至 lombok.NonNull。

• import org.checkerframework.checker.nullness.qual.Nullable;



• @Nullable


• private Object returnNullable() {


• return null;


• }



• public void testReturnNullable() {


• Object obj = returnNullable();


• // 错误：obj 可能为空


• System.out.println(obj.toString());


• }



Checker Framework 默认会将 @NonNull 应用到所有的函数参数和返回值上，因此，即使不添加这个注解，以下程序也是无法编译通过的：

• private Object returnNonNull() {


• // 错误：方法声明为 @NonNull，但返回的是 null。


• return null;


• }



• private void argumentNonNull(Object arg) {


• System.out.println(arg.toString());


• }



• public void testArgumentNonNull() {


• // 错误：参数声明为 @NonNull，但传入的是 null。


• argumentNonNull(null);


• }



Checker Framework 对使用 Spring Framework 5.0 以上的用户非常有用，因为 Spring 提供了内置的空值检测注解，且能够被 Checker Framework 支持。一方面我们无需再引入额外的 Jar 包，更重要的是 Spring Framework 代码本身就使用了这些注解，这样我们在调用它的 API 时就能有效地处理空值了。举例来说，StringUtils 类里可以传入空值的函数、以及会返回空值的函数都添加了 @Nullable 注解，而未添加的方法则继承了整个框架的 @NonNull 注解，因此，下列代码中的空指针异常就可以被 Checker Framework 检测到了：

• // 这是 spring-core 中定义的类和方法


• public abstract class StringUtils {


• // str 参数继承了全局的 @NonNull 注解


• public static String capitalize(String str) {}



• @Nullable


• public static String getFilename(@Nullable String path) {}


• }



• // 错误：参数声明为 @NonNull，但传入的是 null。


• StringUtils.capitalize(null);



• String filename = StringUtils.getFilename("/path/to/file");


• // 错误：filename 可能为空。


• System.out.println(filename.length());



Optional 类型

Java 8 引入了 Optional<T> 类型，我们可以用它来对函数的返回值进行包装。这种方式的优点是可以明确定义该方法是有可能返回空值的，因此调用方必须做好相应处理，这样也就不会引发空指针异常。但是，也不可避免地需要编写更多代码，而且会产生很多垃圾对象，增加 GC 的压力，因此在使用时需要酌情考虑。

• Optional<String> opt;



• // 创建


• opt = Optional.empty();


• opt = Optional.of("text");


• opt = Optional.ofNullable(null);



• // 判断并读取


• if (opt.isPresent()) {


• opt.get();


• }



• // 默认值


• opt.orElse("default");


• opt.orElseGet(() -> "default");


• opt.orElseThrow(() -> new NullPointerException());



• // 相关操作


• opt.ifPresent(value -> {


• System.out.println(value);


• });


• opt.filter(value -> value.length() > 5);


• opt.map(value -> value.trim());


• opt.flatMap(value -> {


• String trimmed = value.trim();


• return trimmed.isEmpty() ? Optional.empty() : Optional.of(trimmed);


• });



方法的链式调用很容易引发空指针异常，但如果返回值都用 Optional 包装起来，就可以用 flatMap 方法来实现安全的链式调用了：

• String zipCode = getUser()


• .flatMap(User::getAddress)


• .flatMap(Address::getZipCode)


• .orElse("");



Java 8 Stream API 同样使用了 Optional 作为返回类型：

• stringList.stream().findFirst().orElse("default");


• stringList.stream()


• .max(Comparator.naturalOrder())


• .ifPresent(System.out::println);



此外，Java 8 还针对基础类型提供了单独的 Optional 类，如 OptionalInt、OptionalDouble 等，在性能要求比较高的场景下很适用。

其它 JVM 语言中的空指针异常

Scala 语言中的 Option 类可以对标 Java 8 的 Optional。它有两个子类型，Some 表示有值，None 表示空。

• val opt: Option[String] = Some("text")


• opt.getOrElse("default")



除了使用 Option#isEmpty 判断，还可以使用 Scala 的模式匹配：

• opt match {


• case Some(text) => println(text)


• case None => println("default")



Scala 的集合处理函数库非常强大，Option 则可直接作为集合进行操作，如 filer、map、以及列表解析（for-comprehension）：

• opt.map(_.trim).filter(_.length > 0).map(_.toUpperCase).getOrElse("DEFAULT")


• val upper = for {


• text <- opt


• trimmed <- Some(text.trim())


• upper <- Some(trimmed) if trimmed.length > 0


• } yield upper


• upper.getOrElse("DEFAULT")



Kotlin 使用了另一种方式，用户在定义变量时就需要明确区分 可空和不可空类型。当可空类型被使用时，就必须进行空值检测。

• var a: String = "text"


• a = null // 错误：无法将 null 赋值给非空 String 类型。



• val b: String? = "text"


• // 错误：操作可空类型时必须使用安全操作符（?.）或强制忽略（!!.）。


• println(b.length)



• val l: Int? = b?.length // 安全操作


• b!!.length // 强制忽略，可能引发空值异常



Kotlin 的特性之一是与 Java 的可互操作性，但 Kotlin 编译器无法知晓 Java 类型是否为空，这就需要在 Java 代码中使用注解了，而 Kotlin 支持的 注解 也非常广泛。Spring Framework 5.0 起原生支持 Kotlin，其空值检测也是通过注解进行的，使得 Kotlin 可以安全地调用 Spring Framework 的所有 API。

结论

在以上这些方案中，我比较推荐使用注解来预防空指针异常，因为这种方式十分有效，对代码的侵入性也较小。所有的公共 API 都应该使用 @Nullable 和 @NonNull 进行注解，这样就能强制调用方对空指针异常进行预防，让我们的程序更为健壮。

❿ grails中blank和nullable的区别

声明约束属性时，blank和nullable好像都能限制非空，那么下面两个语句的区别在哪里：
name(blank:false)
dateOfBirth(nullable:false)
一:

blank用于约束String数据，nullable用于约束对象
name是String类型，所以用blank，dateOfBirth声明时用的是new Date()，因此用nullable
二:
不赞同4楼的回复。我给你举个例子：
String name1
String name2
String name3
String name4
static constraints =
{
name1(nullable:false,blank:false)
name2(nullable:false,blank:true)
name3(nullable:true,blank:false)
name4(nullable:true,blank:true)
}
映射到数据库的DDL语句为：
CREATE TABLE `test` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`version` bigint(20) NOT NULL,
`name1` varchar(255) NOT NULL,
`name2` varchar(255) NOT NULL,
`name3` varchar(255) DEFAULT NULL,
`name4` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
而且此时页面校验要求只有name1是必填的。

如果还不能理解，附带这两个sql，看下效果：
select * from test where name3 = '';
select * from test where name3 is null;