Java 更新方法中的选项始终运行并将值设置为0

Im在update方法中使用Optionals，一旦运行该方法，就会更新相应的postgres db列，前几个是字符串，更新很好。最后两个是INT（authorization和chaperprogress），当我调用第一个来更新其值时，它会将另一个基于INT的可选值设置为0，反之亦然。问题代码为以下最后两个选项：

private final UserDao userDao;

//constructor
@Autowired
public UserService(@Qualifier("postgres1")UserDao userDao) {
    this.userDao= userDao;
}
//methods

public int addUser(UUID id,User user) {
    UUID newId = Optional.ofNullable(id)
            .orElse(UUID.randomUUID());
    return userDao.insertUser(newId,user);
}

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

@GetMapping
public Optional<User> getUserById(UUID id){
    return userDao.selectUserByID(id);
}

public int deleteUser(UUID id) {
    return userDao.deleteUserById(id);
}

@PutMapping
public void updateUser(UUID id, User user) {

Optional.ofNullable(user.getSurname())
.filter(surname -> !StringUtils.isEmpty(surname))
.map(StringUtils::capitalize)
.ifPresent(surname -> userDao.updateSurname(id, surname));

Optional.ofNullable(user.getFirstname())
.filter(firstname -> !StringUtils.isEmpty(firstname))
.map(StringUtils::capitalize)
.ifPresent(firstname -> userDao.updateFirstname(id, firstname));

Optional.ofNullable(user.getUsername())
.filter(uname -> !StringUtils.isEmpty(uname))
.ifPresent(uname -> userDao.updateUsername(id, uname));

Optional.ofNullable(user.getPassword())
.filter(pw -> !StringUtils.isEmpty(pw))
.ifPresent(pw -> userDao.updatePassword(id, pw));

Optional.ofNullable(user.getAuthorisation())
.filter(auth -> !StringUtils.isEmpty(auth))
.ifPresent(auth -> userDao.updateAuthorisation(id, auth));

Optional.ofNullable(user.getChapterProgress())
.filter(cp -> !StringUtils.isEmpty(cp))
.ifPresent(cp -> userDao.updateChapterProgress(id, cp));

}

private final UserDao UserDao；
//建造师
@自动连线
公共用户服务（@Qualifier（“postgres1”）UserDao UserDao）{
this.userDao=userDao；
}
//方法
public int addUser（UUID id，User User）{
UUID newId=可选。不可用（id）
.orElse（UUID.randomUUID（））；
返回userDao.insertUser（newId，user）；
}
公共列表getAllUsers（）{
返回userDao.selectAllUsers（）；
}
@GetMapping
公共可选getUserById（UUID id）{
返回userDao，选择userbyid（id）；
}
public int deleteUser（UUID id）{
返回userDao.deleteUserById（id）；
}
@PutMapping
public void updateUser（UUID id，用户）{
可选的.ofNullable（user.getNames（））
.filter（姓氏->！StringUtils.isEmpty（姓氏））
.map（StringUtils:：大写）
.ifPresent（姓氏->userDao.updateSurname（id，姓氏））；
可选.ofNullable（user.getFirstname（））
.filter（firstname->！StringUtils.isEmpty（firstname））
.map（StringUtils:：大写）
.ifPresent（firstname->userDao.updateFirstname（id，firstname））；
可选.ofNullable（user.getUsername（））
.filter（uname->！StringUtils.isEmpty（uname））
.ifPresent（uname->userDao.updateUsername（id，uname））；
可选.ofNullable（user.getPassword（））
.filter（pw->！StringUtils.isEmpty（pw））
.ifPresent（pw->userDao.updatePassword（id，pw））；
可选.ofNullable（user.getAuthorization（））
.filter（auth->！StringUtils.isEmpty（auth））
.ifPresent（auth->userDao.updateAuthorization（id，auth））；
可选.ofNullable（user.getchaperProgress（））
.filter（cp->！StringUtils.isEmpty（cp））
.ifPresent（cp->userDao.updatechaperprogress（id，cp））；
}

我试着在每个页面上注释掉.filter行，但没有任何更改

用户Dao看起来像这样

public interface UserDao {

int insertUser(UUID id, User user);//good

default int insertUser(User user) {//good
    UUID id = UUID.randomUUID();
    return insertUser(id, user);
}

List<User> selectAllUsers();//good

Optional<User> selectUserByID(UUID id);//good

int deleteUserById(UUID id);//good

int updateUserById(UUID id, User newUser);//good

int updateSurname(UUID id, String surname);//good

int updateFirstname(UUID id, String firstname);//good

int updateUsername(UUID id, String username);//good

int updatePassword(UUID id, String password);//good

int updateAuthorisation(UUID id, int authorisation);//

int updateChapterProgress(UUID id, int chapterProgress);//

公共接口UserDao{
int insertUser（UUID id，User）；//很好
默认int插入器（用户）{//good
UUID id=UUID.randomuid（）；
返回插入器（id，用户）；
}
列出selectAllUsers（）；//很好
可选selectUserByID（UUID id）；//很好
int deleteUserById（UUID id）；//很好
int updateUserById（UUID id，User newUser）；//很好
int updateSurname（UUID id，字符串姓氏）；//很好
int updateFirstname（UUID id，String firstname）；//很好
int updateUsername（UUID id，字符串用户名）；//很好
int updatePassword（UUID id，字符串密码）；//很好
int更新授权（UUID id，int授权）//
int UPDATECHAPERPROGRESS（UUID id，int CHAPERPROGRESS）//

并在UserDataAccessServcie中实现，如下所示：

private JdbcTemplate jdbcTemplate;

@Autowired
public UserDataAccessService(JdbcTemplate jdbcTemplate) {
    this.jdbcTemplate= jdbcTemplate;
}

@Override//create
public int insertUser(UUID id, User user) {
    String sql ="INSERT INTO users(id,surname,firstname,username,password,authorisation,chapterprogress) VALUES (?,?,?,?,?,?,?);";
    return jdbcTemplate.update(sql,id,
            user.getSurname(),
            user.getFirstname(),
            user.getUsername(),
            user.getPassword(),
            user.getAuthorisation(),
            user.getChapterProgress()
    );
}

@Override//read all
public List<User> selectAllUsers() {
final String sql= "SELECT * FROM users";
    return jdbcTemplate.query(sql, (resultSet,i)->{
        return new User(UUID.fromString(
                resultSet.getString("id")),
                resultSet.getString("surname"),
                resultSet.getString("firstName"),
                resultSet.getString("userName"),
                resultSet.getString("password"),
                resultSet.getInt("authorisation"),
                resultSet.getInt("chapterProgress"));
    });
}

@Override//read single
public Optional<User> selectUserByID(UUID id) {
    final String sql= "SELECT * FROM users WHERE id=?";
    User user= jdbcTemplate.queryForObject(sql, new Object[] {id}, (resultSet,i) ->{
        return new User(
                UUID.fromString(resultSet.getString("id")),
                resultSet.getString("surname"), ("firstName"), ("userName"), ("password"),
                resultSet.getInt("authorisation"),
                resultSet.getInt("chapterProgress"));
    });
    return Optional.ofNullable(user);
}

@Override//update//possibly to authorisation problem, consider changing 
        //to void to stop returning a '0'
public int updateUserById(UUID id, User newUser) {
    return 1;
}

@Override
public int updateSurname(UUID id, String surname) {
    String sql ="UPDATE users"
            + " SET surname = ? "
            + "WHERE id = ?";
    return jdbcTemplate.update(sql, surname, id);
}

@Override
public int updateFirstname(UUID id, String firstname) {
    String sql ="UPDATE users SET firstName = ? WHERE id = ?";
    return jdbcTemplate.update(sql, firstname, id);
}

@Override
public int updateUsername(UUID id, String username) {
    String sql = "UPDATE users SET username = ? WHERE id = ?";
    return jdbcTemplate.update(sql, username, id);
}

@Override
public int updatePassword(UUID id, String password) {
    String sql = "UPDATE users SET password = ? WHERE id = ?";
    return jdbcTemplate.update(sql, password, id);
}

@Override
public int updateAuthorisation(UUID id, int authorisation) {
    String sql = "UPDATE users SET authorisation = ? WHERE id = ?";
    return jdbcTemplate.update(sql, authorisation, id);
}

@Override
public int updateChapterProgress(UUID id, int chapterProgress) {
    String sql = "UPDATE users SET chapterprogress = ? WHERE id = ?";
    return jdbcTemplate.update(sql, chapterProgress, id);
}

@Override//delete
    public int deleteUserById(UUID id) {
        final String sql= "DELETE FROM users WHERE id=?";
        jdbcTemplate.update(sql, id);
        return 1;
    }

私有JdbcTemplate JdbcTemplate；
@自动连线
公共UserDataAccessService（JdbcTemplate JdbcTemplate）{
this.jdbcTemplate=jdbcTemplate；
}
@重写//创建
公共int插入器（UUID id，用户）{
String sql=“在用户（id、姓氏、名字、用户名、密码、授权、ChaperLogress）中插入值（？，，，，，，，，？，，？）；”；
返回jdbcTemplate.update（sql，id，
user.getNames（），
user.getFirstname（），
user.getUsername（），
user.getPassword（），
user.getAuthorization（），
user.getChapterProgress（）
);
}
@覆盖//全部读取
公共列表selectAllUsers（）{
最后一个字符串sql=“选择*来自用户”；
返回jdbcTemplate.query（sql，（resultSet，i）->{
返回新用户（UUID.fromString(
resultSet.getString（“id”），
resultSet.getString（“姓氏”），
resultSet.getString（“名字”），
resultSet.getString（“用户名”），
resultSet.getString（“密码”），
结果集getInt（“授权”），
resultSet.getInt（“chaperProgress”）；
});
}
@重写//读取单个
公共可选selectUserByID（UUID id）{
最终字符串sql=“从id=？”的用户中选择*；
User User=jdbcTemplate.queryForObject（sql，新对象[]{id}，（resultSet，i）->{
返回新用户(
UUID.fromString（resultSet.getString（“id”）），
resultSet.getString（“姓氏”）、（“名字”）、（“用户名”）、（“密码”），
结果集getInt（“授权”），
resultSet.getInt（“chaperProgress”）；
});
返回可选。不可用（用户）；
}
@覆盖/ /更新/ /或授权问题，考虑改变
//若要作废，请停止返回“0”
public int updateUserById（UUID id，用户newUser）{
返回1；
}
@凌驾
public int updateSurname（UUID id，字符串姓氏）{
String sql=“更新用户”
+“设置姓氏=？”
+“其中id=？”；
返回jdbcTemplate.update（sql、姓氏、id）；
}
@凌驾
public int updateFirstname（UUID id，字符串名）{
String sql=“UPDATE users SET firstName=？其中id=？”；
返回jdbcTemplate.update（sql，firstname，id）；
}
@凌驾
public int updateUsername（UUID id，字符串用户名）{
String sql=“更新用户集用户名=？其中id=？”；
返回jdbcTemplate.update（sql、用户名、id）；
}
@凌驾
public int updatePassword（UUID id，字符串密码）{
String sql=“更新用户设置密码=？其中id=？”；
返回jdbcTemplate.update（sql、密码、id）；
}
@凌驾
公共int更新授权（UUID id，int授权）{
String sql=“更新用户设置授权=？其中id=？”；
返回jdbcTemplate.update（sql、授权、id）；
}
@凌驾
public int-updatechapecropgress（UUID id，int-chapecropgress）{
String sql=“更新用户集chaperprogress=？其中id=？”；
返回jdbcTemplate.update（sql，chapterProgress，id）；
}
@覆盖//删除
public int deleteUserById（UUID id）{
最后一个字符串sql=“从id=？”的用户中删除”；
jdbcTemplate.update（sql，id