Java глобальная ошибка

Автор оригинала: baeldung.

1. Обзор

В этом уроке мы сосредоточимся на глобальном обработчике исключений в Java. Сначала мы обсудим основы исключений и обработки исключений. Затем мы подробно рассмотрим глобальный обработчик исключений.

Чтобы узнать больше об исключениях в целом, взгляните на обработку исключений в Java .

2. Что такое исключение?

Исключение-это ненормальное состояние, возникающее в последовательности кода во время выполнения или во время компиляции. Это ненормальное состояние возникает, когда программа нарушает семантические ограничения языка программирования Java.

Исключения, возникающие во время компиляции, являются проверенными исключениями . Эти исключения являются прямыми подклассами класса Exception , и необходимо обрабатывать эти исключения в коде.

Другим типом исключений являются непроверенные исключения . Компилятор не проверяет наличие этих исключений во время компиляции. Эти исключения являются прямыми подклассами класса RuntimeException , который расширяет класс Exception .

Кроме того, нет необходимости обрабатывать исключения во время выполнения в коде.

3. Обработчики Исключений

Java-это надежный язык программирования. Одной из основных функций, которая делает его надежным, является структура обработки исключений. Это означает, что программа может изящно выйти в момент ошибки, а не просто сбой.

Всякий раз, когда возникает исключение , объект E exception создается либо JVM, либо методом, выполняющим код. Этот объект содержит информацию об исключении. Обработка исключений-это способ обработки этого Исключения объекта.

3.1. Блок try-catch

В следующем примере блок try содержит код, который может вызвать исключение. Блок catch содержит логику обработки этого исключения.

Блок catch ловит объект Exception , который вызывает код в блоке try :

String string = "01, , 2010";
DateFormat format = new SimpleDateFormat("MM, dd, yyyy");
Date date;
try {
    date = format.parse(string);
} catch (ParseException e) {
    System.out.println("ParseException caught!");
}

3.2. Бросок и ключевые слова бросков

В качестве альтернативы метод также может выбрать выбрасывание исключения вместо его обработки. Это означает, что логика обработки объекта Exception записана где-то в другом месте.

Обычно вызывающий метод обрабатывает исключение в таких случаях:

public class ExceptionHandler {

    public static void main(String[] args) {

        String strDate = "01, , 2010";
        String dateFormat = "MM, dd, yyyy";
		
        try {
            Date date = new DateParser().getParsedDate(strDate, dateFormat);
        } catch (ParseException e) {
            System.out.println("The calling method caught ParseException!");
        }
    }
}

class DateParser {
	
    public Date getParsedDate(String strDate, String dateFormat) throws ParseException {
        DateFormat format = new SimpleDateFormat(dateFormat);
        
        try {
            return format.parse(strDate);
        } catch (ParseException parseException) {
            throw parseException;
        }		
    }
	
}

Далее мы рассмотрим Глобальный обработчик исключений как универсальный способ обработки исключений.

4. Глобальный обработчик Исключений

Экземпляры RuntimeException не являются обязательными для обработки. Следовательно, он по-прежнему оставляет открытым окно для получения длинных трассировок стека во время выполнения. Чтобы справиться с этим, Java предоставляет UncaughtExceptionHandler интерфейс . Класс Thread содержит это как внутренний класс.

В дополнение к этому интерфейсу в выпуске Java 1.5 также был представлен статический метод setDefaultUncaughtExceptionHandler() в классе Thread . Аргументом этого метода является класс обработчика, реализующий интерфейс UncaughtExceptionHandler .

Кроме того, этот интерфейс объявляет метод uncaughtException(Thread t, Throwable e) . Он будет вызван, когда данный поток t завершится из-за данного неперехваченного исключения e . Реализующий класс реализует этот метод и определяет логику обработки этих неперехваченных исключений.

Давайте рассмотрим следующий пример, который вызывает исключение ArithmeticException во время выполнения. Мы определяем класс Обработчик , реализующий интерфейс UncaughtExceptionHandler .

Этот класс реализует метод uncaughtException() и определяет логику для обработки в нем неперехваченных исключений:

public class GlobalExceptionHandler {

    public static void main(String[] args) {

        Handler globalExceptionHandler = new Handler();
        Thread.setDefaultUncaughtExceptionHandler(globalExceptionHandler);
        new GlobalExceptionHandler().performArithmeticOperation(10, 0);
    }

    public int performArithmeticOperation(int num1, int num2) {
        return num1/num2;
    }
}

class Handler implements Thread.UncaughtExceptionHandler {

    private static Logger LOGGER = LoggerFactory.getLogger(Handler.class);

    public void uncaughtException(Thread t, Throwable e) {
        LOGGER.info("Unhandled exception caught!");
    }
}

Здесь текущий выполняющийся поток является основным потоком. Таким образом, его экземпляр передается методу uncaughtException() вместе с вызванным исключением. Затем класс Обработчик обрабатывает это исключение.

То же самое относится и к необработанным проверенным исключениям. Давайте также рассмотрим краткий пример этого:

public static void main(String[] args) throws Exception {
    Handler globalExceptionHandler = new Handler();
    Thread.setDefaultUncaughtExceptionHandler(globalExceptionHandler);
    Path file = Paths.get("");
    Files.delete(file);
}

Вот файлы .метод delete() вызывает проверенное исключение IOException, которое далее вызывается сигнатурой метода main () . Обработчик | также перехватит это исключение.

Таким образом, UncaughtExceptionHandler помогает управлять необработанными исключениями во время выполнения. Однако это нарушает идею перехвата и обработки исключения вблизи точки происхождения .

5. Заключение

В этой статье мы потратили время, чтобы понять, что такое исключения и каковы основные способы их обработки. Кроме того, мы определили, что глобальный обработчик исключений является частью класса Thread и обрабатывает неперехваченные исключения во время выполнения.

Затем мы увидели пример программы, которая создает исключение runtimeexception и обрабатывает его с помощью глобального обработчика исключений.

Примеры кодов для этой статьи можно найти на GitHub .

You probobly don’t want to mail on any exception. There are lots of code in the JDK that actaully depend on exceptions to work normally. What I presume you are more inerested in are uncaught exceptions. If you are catching the exceptions you should handle notifications there.

In a desktop app there are two places to worry about this, in the event-dispatch-thread (EDT) and outside of the EDT. Globaly you can register a class implementing java.util.Thread.UncaughtExceptionHandler and register it via java.util.Thread.setDefaultUncaughtExceptionHandler. This will get called if an exception winds down to the bottom of the stack and the thread hasn’t had a handler set on the current thread instance on the thread or the ThreadGroup.

The EDT has a different hook for handling exceptions. A system property 'sun.awt.exception.handler' needs to be registerd with the Fully Qualified Class Name of a class with a zero argument constructor. This class needs an instance method handle(Throwable) that does your work. The return type doesn’t matter, and since a new instance is created every time, don’t count on keeping state.

So if you don’t care what thread the exception occurred in a sample may look like this:

class ExceptionHandler implements Thread.UncaughtExceptionHandler {
  public void uncaughtException(Thread t, Throwable e) {
    handle(e);
  }

  public void handle(Throwable throwable) {
    try {
      // insert your e-mail code here
    } catch (Throwable t) {
      // don't let the exception get thrown out, will cause infinite looping!
    }
  }

  public static void registerExceptionHandler() {
    Thread.setDefaultUncaughtExceptionHandler(new ExceptionHandler());
    System.setProperty("sun.awt.exception.handler", ExceptionHandler.class.getName());
  }
}

Add this class into some random package, and then call the registerExceptionHandler method and you should be ready to go.

После того, как я недавно закончил несколько проектов, я должен начать обобщать некоторые вещи. Раньше я писал небольшие заметки, прежде чем что-то узнал. Теперь я должен начать разбираться с вещами медленно. Первый блог, дорога у подножия, Надеюсь, вы не расслабитесь!

Понять «аномалии»

1. Классификация аномалий

Рисунок выше представляет собой простую схематическую диаграмму иерархии исключений в дизайне языка программирования Java.Все исключения наследуются Throwable, а следующий уровень делится на Error и Exception

ErrorОписывает некоторые ошибки и ошибки исчерпания ресурсов в системе времени выполнения Java, мы не должны бросать этот тип объекта в приложение. Если это произойдет, все, что вы можете сделать, это уведомить пользователя о том, что произошла ошибка, и завершить ее как можно безопаснее. Непосредственно известные подклассы:

AnnotationFormatError(Выдает, когда анализатор комментариев пытается прочитать комментарии из файла класса и определяет, что комментарии искажены.Используется для отражения чтения комментариевизAPIЭту ошибку можно выкинуть)

AssertionError(Бросок указывает на ошибку утверждения)

CoderMalfunctionError(Сбрасывает, когда возникает непредсказуемая ошибка в методе decodeLoop CharsetDecoder или метод encodeLoop в CharsetEncoder)

FactoryConfigurationError(Выдается при возникновении проблемы с конфигурацией фабрики синтаксических анализаторов. Обычно эта ошибка генерируется, когда класс фабрики синтаксических анализаторов, указанный в системных свойствах, не может быть найден или создан)

IOError(Выдает при возникновении серьезной ошибки ввода-вывода)

 LinkageError(ПодклассLinkageErrorУказывает, что один класс имеет некоторые зависимости от другого класса, однако последний класс имеет противоречивые изменения после компиляции предыдущего класса)

 ThreadDeath(При вызове метода Thread.stop () экземпляр выбрасывается в поток)

TransformerFactoryConfigurationError(Вызывается, когда возникают проблемы с конфигурацией фабрики трансформаторов. Обычно эта ошибка выдается, когда класс фабрики преобразований, указанный в системных свойствах, не может быть найден или создан)

AWTError(Бросить при возникновении серьезной ошибки Abstract Window Toolkit)

VirtualMachineError(Создание этого исключения означает, что виртуальная машина Java повреждена или исчерпала ресурсы, необходимые для продолжения работы)

StackOverFlowError: Эта ошибка возникает из-за слишком глубокой рекурсии. Фактически, настоящая причина в том, что операция потока Java основана на стеке. Когда вызывается внутренний метод метода, то есть, когда выполняется рекурсия, текущий метод помещается в стек до тех пор, пока метод внутри метода После завершения выполнения он вернется к предыдущему методу, то есть последний метод будет выполнен после операции стека. Примеры этой ситуации:

public class StackOverflowTest {  

    public static void main(String[] args){  
        test();  
    }  
    private static void test() {  
        test();  
    }  
}

OutOfMemoryError: Из-за памяти, JVM не может выделить пространство для создания объекта и GC не в состоянии восстановить достаточно места, когда вы создаете объект быстрее, чем скорость, когда восстановление пространства JVM недостаточно места будет происходить эта проблема случаются примеры :

public class OutOfMemoryTest {  

    public static void main(String[] args){  
        List<Object> testlist = new ArrayList<Object>();  
        while(true){  
            int[] index = new int[20_0000_0000];  
            testlist.add(index);  
        }  
    }  
}  

Exception: Класс делится на две ветви, по правилам делятся на

checked ExceptionПри написании кода, IDE (например, Eclipse) спросит васВид исключения написано попробуй поймай, Такие как IOException. Это исключение — то, что Java-дизайнеру требуется для обработки вашей программы. Такое исключение обычно не влияет на основную часть программы, и его легко диагностировать и исправлять вручную, поэтому Java требует, чтобы вы написали код обработки под перехватом, чтобы гарантировать, что программа все еще сможет нормально работать после возникновения такого исключения.

• Класс ClassNotFoundException не найден
• CloneNotSupportedException при попытке клонировать объект, который не может реализовать интерфейс Cloneable
• invalidAccessException Доступ к классу запрещен
• InstantiationException при попытке создать экземпляр объекта абстрактного класса или абстрактного интерфейса
• InterruptedException Поток был прерван другим потоком
• NosuchFieldException Запрошенное поле не существует
• NosucnMethodException Запрошенный метод не существует

uncheckedЭта категория является исключением, с которым вы все еще будете сталкиваться, когда код обрабатывает проверенное исключение, поэтому она также называетсяRunTimeException, Например, NullPointerException, IndexOutOfBoundsException. Этот тип исключения, скорее всего, повлияет на работу программы, чем предыдущий. С точки зрения дизайнера, не рекомендуется отлавливать и обрабатывать из программы. Конечно, вы можете сделать то же самое.

• ClassCastException неправильное преобразование типов
• ArrayIndexOutOfBoundsException Массив доступа за пределы
• NullPointerException доступ к нулевому указателю
• ArithmeticException делитель равен 0
• NumberFormatException преобразовать строку в число
• IllegalArgumentException передал недопустимый параметр
• UnsupportedOperationException Эта операция не поддерживается, например, исключения, возникающие при вызове add и remove после использования Arrays.asList (). Список, сгенерированный этим методом, является внутренним классом ArrayList of Array, который отличается от java.util.ArrayList. (Методы выбрасывают такие исключения по умолчанию), но util.ArrayList переопределяет эти методы
• StringIndexOutOfBoundsException Строка выходит за границы, например, str.subString (100), индекс находится вне диапазона
• В среде Spring все исключения SQL переписываются как RuntimeException org.springframework, и транзакция будет откатываться! (Некоторые исключения в Sprng)
•  java.lang.Object
                                 |____java.lang.Throwable
                                      |____ java.lang.Exception
                                           |____ java.lang.RuntimeException
                                                |____ org.springframework.core.NestedRuntimeException
                                                    |____org.springframework.dao.DataAccessException
                                                         |____  org.springframework.dao.NonTransientDataAccessException
                                                             |____org.springframework.dao.DataIntegrityViolationException
                                                                 |____org.springframework.dao.DuplicateKeyException
  Декомпиляция видна: Все исключения в org.springframework.dao являются подклассами RuntimeException

2. Сбор и обработка исключений

Обработка исключений в Java обычно использует try catch finally throws бросает эти операторы управления, следующие детали их использования

1. Как использовать

OutputStream os = null
try {
    is = new FileOutputStream(new File("C:\iphonefile\BuickDealerPlatform.ipa"))
    Возможен ненормальный блок кода 
} catch(IOException e) {
         e.printStackTrace (); // стек исключений печати
         throw new UserDefinedException ("", e); // Вручную выбрасывать объект пользовательского исключения
         // Или сделать что-то еще
} catch(ExceptionName e) {
    ...
         // Обработка мер, когда генерируется исключение, такое как ExceptionName
} finally {
    if (os != null) {
        os.close()
    }
    ...    
         // Код, который должен быть обработан независимо от того, перехвачено ли исключение, обычно используется для закрытия потока, закрытия ресурса и удаления временных файлов
}


 // После Java SE7 существует метод записи try-with-resource. Закрытие ресурсов выполняется напрямую try, без записи finally
static String readFirstLineFromFile(String path) throws IOException {
    try(BufferedReader br = new BufferedReader(new FileReader(path))) {
        return br.readLine();
    } 
}

 // Некоторые люди говорят, что это неудобно. После чтения потока файлов другие коды сообщают об ошибках, и поток файлов не может быть освобожден нормально. Я в основном использую этот способ написания в проекте, и пока нет ошибок.

Приведенный выше код в основном использует эти ключевые слова, пытается обернуть блок кода, который мы хотим обработать, перехватить, чтобы перехватить исключение, которое мы хотим перехватить, и выполнить соответствующую обработку, наконец, выполнить окончательную работу, которая должна быть выполнена, и SE7 Использование функции try-with-resource

2. В чем разница между бросками и бросками

throw: оператор бросает исключение, и написание этого предложения действительно собирается выбросить это исключение. Появляется в теле метода

if(i > 3) {
         бросить новый MyselfException («Число слишком большое»)
}

throws: объявлять, что этот метод может выбрасывать эти исключения, так что его вызывающая сторона знает, что делать с этими исключениями. Появляется на голове метода

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
		//allow cross-origin access
		HttpServletResponse res = (HttpServletResponse)response;
		res.setHeader("Access-Control-Allow-Origin", "*");
		res.setHeader("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE");
		res.setHeader("Access-Control-Max-Age", "3600");
		res.setHeader("Access-Control-Allow-Headers", "content-type,x-requested-with");
		res.setHeader("Access-Control-Allow-Credentials","true");

		chain.doFilter(request, response);
	}

Являются ли все негативные способы обработки, выбрасывая исключение и позволяя другим обрабатывать его?

3.произвести заказ

• Независимо от того, есть ли исключения в блоке кода, если есть блок finally, код в конечном итоге будет выполнен
• В try catch есть оператор return, а в finally нет возврата:Тогда, если тип упаковки, статические переменные и глобальные переменные не будут изменены в finally, это не повлияет на возвращаемое значение в try catch.Если нет исключений в try и try и есть return, выполните код выше return перед выполнением return. После операции, а затем выполните код finally, а затем вернитесь, чтобы попытаться вернуть значение. То же самое верно при возвращении в улове;
• В try catch есть оператор return, а в finally: return:Как правило, не рекомендуется использовать return в finally для выполнения только некоторых закрывающих действий. Если здесь есть возврат, то возвращение в блоках try и catch перед возвращением будет проходить через finally. В это время, если есть возврат в finally, он будет возвращаться напрямую.

Обработка исключений, используемая в проекте SpringBoot

Прежде всего, нам необходимо уточнить общую структуру обработки исключений в проекте. Обработка исключений, используемая в проекте Spring Boot, который мы в настоящее время делаем: классы инструментов компонентов Controller, Service, Dao и UtilComponent создают свои собственные пользовательские настройки в своих собственных слоях. Этот слой объектов исключений, например, сначала мы определяем BaseException, а затем определяем четыре пользовательских класса исключений для слоя: ControllerException, ServiceException, DaoException, ComponentException, все они наследуют BaseException. Создание нового ExceptionName («информация об исключении», e) на каждом уровне обрабатывается созданным нами ExceptionMapper, который перепаковывает информацию об исключении и возвращает ответ на стойку регистрации. Конкретный код выглядит следующим образом:

public abstract class BaseException extends RuntimeException {

    protected int errCode;

    protected String errMsg;

    public BaseException(Throwable e) {
        super(e);
    }
    public BaseException(String msg) {
        super(msg);
    }
    public BaseException(String msg, Throwable throwable) {
        super(msg, throwable);
    }

    public int getErrCode() {
        return errCode;
    }

    public void setErrCode(int errCode) {
        this.errCode = errCode;
    }

    public String getErrMsg() {
        return errMsg;
    }

    public void setErrMsg(String errMsg) {
        this.errMsg = errMsg;
    }
}

public class ControllerException extends BaseException {

    public ControllerException(Throwable throwable) {
        super(throwable);
    }

    public ControllerException(String errMsg) {
        super(errMsg);
        this.errMsg = errMsg;
    }

    public ControllerException(String errMsg, Throwable throwable) {
        super(errMsg, throwable);
        this.errMsg = errMsg;
    }

    public ControllerException(int errCode, String errMsg, Throwable throwable) {
        super(errMsg, throwable);
        this.errCode = errCode;
        this.errMsg = errMsg;
    }
}

public class ServiceException extends BaseException {

    public ServiceException(Throwable throwable) {
        super(throwable);
    }

    public ServiceException(String errMsg) {
        super(errMsg);
        this.errMsg = errMsg;
    }

    public ServiceException(String errMsg, Throwable throwable) {
        super(errMsg, throwable);
        this.errMsg = errMsg;
    }

    public ServiceException(int errCode, String errMsg, Throwable throwable) {
        super(errMsg, throwable);
        this.errCode = errCode;
        this.errMsg = errMsg;
    }
}

public class ComponentException extends BaseException {

    public ComponentException(Throwable throwable) {
        super(throwable);
    }

    public ComponentException(String errMsg) {
        super(errMsg);
        this.errMsg = errMsg;
    }

    public ComponentException(String errMsg, Throwable throwable) {
        super(errMsg, throwable);
        this.errMsg = errMsg;
    }
    public ComponentException(int errCode, String errMsg, Throwable throwable) {
        super(errMsg, throwable);
        this.errCode = errCode;
        this.errMsg = errMsg;
    }
}

public class APPMSExceptionMapper implements ExceptionMapper<Exception> {

	private static org.slf4j.Logger logger = LoggerFactory.getLogger(APPMSExceptionMapper.class);

	@Override
	public Response toResponse(Exception e) {
		 // Здесь выводятся все исключения
		logger.error(e.getMessage(),e);

		ExceptionResponse result = this.createResponse(e);
		return Response.status(Status.BAD_REQUEST.getStatusCode()).entity(result).type(MediaType.APPLICATION_JSON).build();
	}

	private ExceptionResponse createResponse(Exception ex) {
		int errorCode = AppMSConstants.EX_DEFAULT_ERROR_CODE;
		String msg = ex.getMessage();

		 // Получить только информацию о вызове, связанную с приложением, в стеке исключений
		StackTraceElement[] traceElements = ex.getStackTrace();
		StringBuilder stackTraceBuilder = new StringBuilder(ex.toString().concat(AppMSConstants.COLON));
		String trackElement;
		for (StackTraceElement element : traceElements) {
			trackElement = element.toString();
			if (trackElement.contains(AppMSConstants.EX_STACK_FILTER_TOKEN)) {
				stackTraceBuilder.append(trackElement.concat(AppMSConstants.SEMICOLON));
			}
		}

		if (ex instanceof BaseException) {
			errorCode = ((BaseException) ex).getErrCode();
		}
		return new ExceptionResponse(errorCode, msg, stackTraceBuilder.toString());
	}

}

try{
    uploadMapper.appUpload(appInfo, appVersion, supportDeviceIdList);
} catch (Exception e) {
         выбросить новое DaoException («Ошибка сохранения информации о приложении, информации о версии и информации о поддерживаемом устройстве», e);
}

Вышеуказанная ситуация состоит в том, чтобы перехватить все слои исключений, а другая — выбросить исключение слой за слоем в контроллер для обработки

Один контроллер обрабатывает исключения:

@RestController
@RequestMapping("/testadvice")
public class TestController {

    @RequestMapping(value = "/test", method = RequestMethod.GET)
    public String test() {
                 бросить новое IOException («Бросить IO исключение»);
    }

    @ExceptionHandler(IOException.class)
    public ControllerExceptionResponse exceptionHandler() {
        ControllerExceptionResponse ge= new ControllerExceptionResponse ();
        ge.setCode(999);
                 ge.setMsg («ловушка исключения IO»);
        return ge;
    }

}

Обработка исключений в рамках всех контроллеров (глобальная)

//@ControllerAdvice(annotations=RestController.class)
//@ControllerAdvice(basePackages={"com.sgm.xxx","com.sgm.ooo"})
@ControllerAdvice
public class GlobalExceptionHandler {

	private static org.slf4j.Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

	@ExceptionHandler(ServiceException.class)
	protected ResponseEntity<ResultDto> processServiceBizException(ServiceException ex) {
		ResultDto result = new ResultDto();
		 logger.error («Исключение из бизнес-логики», ex);
		logger.error(getStackMessage(ex));
		result.setStatus(String.valueOf(ex.getErrCode()));
		result.setMessage(ex.getMessage());
		return new ResponseEntity<ResultDto>(result, HttpStatus.FORBIDDEN);
	}

	@ExceptionHandler(DaoException.class)
	protected ResponseEntity<ResultDto> processDaoException(DaoException ex) {
		ResultDto result = new ResultDto();
		 logger.error («Исключение из базы данных», ex);
		logger.error(getStackMessage(ex));
		result.setStatus(String.valueOf(ex.getErrCode()));
		result.setMessage(ex.getMessage());
		return new ResponseEntity<ResultDto>(result, HttpStatus.INTERNAL_SERVER_ERROR);
	}

	@ExceptionHandler(MethodArgumentNotValidException.class)
	protected ResponseEntity<ResultDto> processMethodArgumentNotValidException(MethodArgumentNotValidException ex) {
		ResultDto result = new ResultDto();
		StringBuffer errorMsgBuffer = new StringBuffer();

		List<ObjectError> errors = ex.getBindingResult().getAllErrors();

		for (ObjectError error : errors) {
			if (errorMsgBuffer.length() > 0)
				errorMsgBuffer.append(";");
			errorMsgBuffer.append(error.getDefaultMessage());
		}
		 logger.error («Исключение при проверке параметров Spring Bean», ex);
		return new ResponseEntity<ResultDto>(result, HttpStatus.FORBIDDEN);
	}

	private String getStackMessage(Throwable throwable) {
		String msg = throwable == null ? "" : throwable.getMessage();
		return msg;
	}

}

@ControllerAdvice — это вспомогательный класс контроллера, наиболее часто используемый класс аспектов для глобальной обработки исключений.

@ControllerAdvice может указать диапазон сканирования

@ControllerAdvice согласовал несколько возможных возвращаемых значений. Если он возвращает класс модели напрямую, вам нужно использовать @ResponseBody для преобразования json

Обработка исключений, используемая в проекте SpringMVC

Обработка исключений в SpringMvc на самом деле такая же, как описано выше: либо выбрасывайте пользовательские исключения из каждого слоя, либо выбрасывайте их в контроллер и обрабатывайте их, но SpringMVC необходимо настроить некоторые из них.

Application.xml для загрузки GlobalExceptionHandler в управление весной

<bean id="globalExceptionHandler" class="com.sgm.midjs.exception.GlobalExceptionHandler"></bean>

Предыдущий проект должен был использовать @ControllerAdvice с аннотацией @ExceptionHandler (ServiceException.class) для создания глобального обработчика исключений. Конкретный код аналогичен приведенному выше, но SpringBoot сохраняет некоторую работу по настройке, которую необходимо выполнить. Соглашение больше, чем конфигурация Ну.

Надеюсь, это полезно.