How to fail when bean annotated with javax.faces.bean.ViewScoped

Is there a way of detecting @Named CDI-Beans which are created with javax.faces.bean.ViewScoped? It happened multiple times to me, that the IDE preferred this annotation to javax.faces.view.ViewScoped.

Is there a good way to just abort the application startup when a javax.faces.bean.ViewScoped annotated CDI-Bean is found?

> Is there a good way to just abort the application startup when a javax.faces.bean.ViewScoped annotated CDI-Bean is found?

Yes! You can use a CDI extension for this as long as you've a bean-discovery-mode="all".

Here's a kickoff example tailored for your specific use case:

package com.stackoverflow.q76653269;

import java.util.HashSet;
import java.util.Set;

import javax.enterprise.event.Observes;
import javax.enterprise.inject.spi.DeploymentException;
import javax.enterprise.inject.spi.Extension;
import javax.enterprise.inject.spi.ProcessAnnotatedType;

public class BadBeansDetector implements Extension {

    <T> void processAnnotatedType(@Observes ProcessAnnotatedType<T> type) {
        Set<Class<?>> badBeans = new HashSet<>();

        if (type.getAnnotatedType().getAnnotation(javax.faces.bean.ViewScoped.class) != null) {
            badBeans.add(type.getAnnotatedType().getJavaClass());
        }
        
        if (!badBeans.isEmpty()) {
            throw new DeploymentException("Bad beans found! " + badBeans);
        }
    }
}

To get it to run, create a META-INF/services/javax.enterprise.inject.spi.Extension text file with the sole content:

com.stackoverflow.q76653269.BadBeansDetector

In case of a Maven WAR project, this META-INF folder must reside in src/main/resources (and thus not src/main/webapp).

In case you've bean-discovery-mode="annotated", then this won't work, but the bad bean would in first place not be injectable and already block deployment with an unsatisfied dependency exception anywhere you @Inject it and you wouldn't need to ask this question.

The alternative is of course to upgrade to JSF 2.3 where this annotation is marked @Deprecated and reconfigure your build/compiler to fail when a deprecated thing is encountered. Yet another alternative is to migrate further to Faces 4.0 where this deprecated annotation is long removed

I think the previous answer is just fine, but another way to catch this at compile time would be to use the Maven Enforcer plugin: https://maven.apache.org/enforcer/maven-enforcer-plugin/usage.html

Then use this rule extensions that can search for banned class usages: https://github.com/skuzzle/restrict-imports-enforcer-rule

The total change in your pom.xml would be something like:

...
<build>
 <plugins>
...

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-enforcer-plugin</artifactId>
    <version>3.3.0</version>
    <dependencies>
        <dependency>
            <groupId>de.skuzzle.enforcer</groupId>
            <artifactId>restrict-imports-enforcer-rule</artifactId>
            <version>2.3.1</version>
        </dependency>
    </dependencies>
    <executions>
        <execution>
            <id>check-viewscopedjsf-imports</id>
            <phase>process-sources</phase>
            <goals>
                <goal>enforce</goal>
            </goals>
            <configuration>
                <rules>
                    <RestrictImports>
                        <reason>Use CDI managed beans, not deprecated JSF APIs</reason>
                        <bannedImport>javax.faces.bean.**</bannedImport>
                    </RestrictImports>
                </rules>
            </configuration>
        </execution>
    </executions>
  </plugin>
 </plugins>
</build>

The advantage of this approach is you'll catch the error while compiling, instead of while running, so it may save you a bit of time depending on your use case. I don't think this will check third party libraries however, which BalusC's solution would do. So if this is a big problem in your stack, you could probably run both solutions for full coverage.